IO
- 概念引入
- 位图的概念
- IO的系统调用函数
- open
- write
- read()
- close
- 简单使用样例:
- 文件描述符fd
- 默认文件流stdin/stdout/stderr
- 文件描述符的分配规则
- 重定向的概念
- 输出重定向
- 输入重定向
- 追加重定向
- dup2()系统调用
- 总结
- 文件缓冲区
- 深入理解缓冲区的概念
- 输出缓冲区部分代码解释
- 总结
- stdout和stderr的区别
- 总结
- 自己实现一个perror
- 文件系统
- inode
- 发现系统还有空间,为什么不能创建文件?
- 软硬链接
概念引入
在学习C语言的时候,我们学过一些文件操作的函数,比如fopen,fgets,fputs,fclose等等,其实这些函数的功能就是在操作文件,进行IO读取工作。这些是C语言封装的函数。
然而C语言封装的函数里面,一定有OS层面的动作,因为IO设计到硬件操作,而对于硬件的操作一定要通过系统调用,让OS帮助我们完成IO操作。
所以,为了更好的让大家理解IO原理,先介绍一下IO的系统调用接口。
位图的概念
在介绍系统调用函数之前,需要了解一下位图的概念。顾名思义就是每个比特位都有不通过的含义,代表着不同的功能。
下面使用一个例子介绍位图的应用:
1 #include<stdio.h>2 3 4 // 用int中的不重复的一个bit,就可以标识一种状态5 // 第1个比特位表示功能一,第二个比特位表示功能二,第三个比特位表示功能三6 #define ONE 0x1 //0000 00017 #define TWO 0x2 //0000 00108 #define THREE 0x4 //0000 01009 10 11 void show(int flags)12 {13 //哪个标志的比特位是1,就完成对应的功能14 if(flags & ONE) printf("功能ONE\n");15 if(flags & TWO) printf("功能TWO\n");16 if(flags & THREE) printf("功能THREE\n");17 }18 19 int main()20 {21 show(ONE); //选择功能122 show(TWO); //选择功能223 show(ONE | TWO); //选择功能1和224 show(ONE | TWO | THREE); //选择功能123 25 return 0;26 }
从上面的运行结果可以来看,我们使用位图的概念,实现了的方法可以选择任意功能。
IO的系统调用函数
open
类比fopen的使用,使用man 2 open查询open函数的用法。我们使用时,经常使用带mode的函数。
第一个参数:文件路径
第二个参数flags:功能位(位图的概念)
第三个参数:权限:可以使用16进制来表示,一般使用0x666表示rw权限。
返回值:成功时返回新打开的文件描述符。失败时:返回-1.
flags:打开文件时,可以传入多个参数选项,用下面的一个或多个常量进行"或"运算,构成flags。
- O_RDONLY:只读打开
- O_WRONLY:只写打开
- O_RDWR:读、写打开 (上面这三个常量,必须写一个且只能写一个)
- O_CREAT:若文件不存在,则创建它。需要使用mode选项,来指明文件的访问权限。
- O_APPEND:追加写。
下面我们简单举个例子来打开文件:
1 #include<stdio.h>2 #include<sys/types.h>3 #include<sys/stat.h>4 #include<fcntl.h>5 6 int main()7 {8 //只读并且没有文件创建。9 int fd = open("log.txt", O_WRONLY|O_CREAT, 0666);// rw-rw-rw 10 if(fd < 0)11 {12 perror("open:");13 return 1;14 }15 16 printf("打开成功, fd %d \n", fd);17 18 return 0;19 }
write
类比fwrite的使用,使用man 2 write查询open函数的用法。
fd:文件描述符
buf:要写的字符串。
count:要写的大小(单位是字节)
返回值:ssize_t :实际写的有效字节数。
read()
类比fread。
将fd的功能读到字符串buf中,读取count个字节。
close
关闭指定文件,通过文件描述符关闭。
返回值:0代表成功。-1代表失败。
简单使用样例:
创建一个log.txt文件,并且追加输入111222333
1 #include<stdio.h>2 #include<string.h>3 #include<stdlib.h>4 #include<unistd.h>5 #include<sys/types.h>6 #include<sys/stat.h>7 #include<fcntl.h>8 9 int main()10 {11 //只读并且没有文件创建,追加写入12 int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);// rw-rw-rw13 if(fd < 0)14 {15 perror("open:");16 return 1;17 }18 19 printf("打开成功, fd %d \n", fd);20 const char* s1 = "111111111111";21 const char* s2 = "222222222222";22 const char* s3 = "3333333333333";23 write(fd, s1, strlen(s1));24 write(fd, s2, strlen(s1));25 write(fd, s3, strlen(s1));26 27 close(fd); 28 29 return 0;30 }
文件描述符fd
通过open系统调用函数的理解,发现文件描述符其实就是一个小整数,并且一直是3,为什么呢?
这就要引入stdin,stdout,stderr的概念。
默认文件流stdin/stdout/stderr
在我们操作系统启动的时候,默认会打开三个流,他们就是stdin,stdout,stderr,即标准输入流、标准输出流、标准错误流。对应的硬件分别是:键盘(让我们能输入)、显示器(让我们能看见)、显示器(出错了也能看见)。
看下面一段程序:
1 #include<stdio.h>4 int main ()5 {6 7 printf("stdin: %d\n",stdin->_fileno);8 printf("stdout: %d\n",stdout->_fileno);9 printf("stderr: %d\n",stderr->_fileno);10 return 0; 11 }12
我们可以猜测,0,1,2是被这默认打开的三个流占用了,所以我们每次再打开文件的时候,被分配的就是从3开始了。
并且在man手册查看一下他们的介绍,发现都是FILE* 类型的。
因此我们猜测FILE是一个结构体,并且结构体的内部一定有fd。当然这个结构体一定是由C语言提供的。
而我们上面学习了系统调用函数,使用的是fd操纵的文件,我们可以推测C语言的文件操作,一定封装了系统调用的接口,并且通过struct FILE里面的fd来和系统沟通,因为系统只认识fd,不认识FILE*。
下面我将fd与文件的关系可视化出来帮助大家理解:
解释:通过进程的pcb里面可以找到一个数组,其中fd就是数组的下标,数组内容存着文件的属性信息。因此当我们打开一个文件的时候,OS会在数组中申请一个最小的下标(通常情况下最小为3),然后内容存上结构体的地址,这样我们就能通过fd操作文件啦。
现在我们知道,文件描述符就是从0开始的小整数。当我们打开文件时,操作系统在内存中要创建相应的数据结构来描述文件。于是就有了file结构体。表示一个已经打开的文件对象。而进程执行open系统调用,所以必须让进程和文件关联起来。每个进程都有一个指针*file,指向一张表files_struct,该表最重要的部分就是包含一个指针数组,每个元素都是一个指向打开文件的指针!所以,本质上,文件描述符fd就是该数组的下标。所以只要拿着文件描述符,就可以找到对应的文件。
文件描述符的分配规则
现在我们已经理清楚,文件描述符是什么,有什么用。那么他的分配规则是什么呢?fd分配最小下标分配原则。
关闭0号文件,那么我们如果打开文件的话描述符就为0,如下:
1 #include<stdio.h>2 #include<string.h>3 #include<stdlib.h>4 #include<unistd.h>5 #include<sys/types.h>6 #include<sys/stat.h>7 #include<fcntl.h>8 9 int main()10 {12 close(0); //关闭0号文件描述符 13 int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);// rw-rw-rw14 if(fd < 0)15 {16 perror("open:");17 return 1;18 }19 20 printf("打开成功, fd %d \n", fd);28 close(fd);30 return 0;31 }
可以验证OS总是优先分配最小的数组下标,即便是0、1、2号下标也不例外!!!
重定向的概念
输出重定向
看一下下面的代码:
1 #include<stdio.h>2 #include<string.h>3 #include<unistd.h>4 #include<sys/types.h>5 #include<sys/stat.h>6 #include<fcntl.h>7 8 int main ()9 {10 11 close(1);12 int fd = open("log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666); //fd的文件描述符为113 //下面的内容本应该打印到屏幕上。但实际上却没有打印出来。14 printf("打开文件分配的fd为%d\n", fd); 15 printf("打印到屏幕上的内容\n");16 fprintf(stdout, "hello fprintf\n");17 const char* s1 = "hello fwrite\n";18 fwrite(s1, 1, strlen(s1), stdout);19 22 fflush(stdout);23 close(fd);24 return 0;25 }
运行结果:本应该显示在屏幕上的内容却被输出到了文件里!这个现象叫做输出重定向,但是为什么呢?
下面我将用图例解释一下产生上面情况的原因:
注意stdin,stdout,stderr在C语言是宏定义,分别被定义成为了0、1、2。在代码中,我们首先关闭了1号文件描述符,然后又打开了文件,显然log.txt文件的文件描述符就是1,也就是说1号下标的内容由标准输出(屏幕)变成了指向log.txt的指针。所以,我们在代码中对stdout文件输出内容,在语言层面其实就是对1号文件描述符输出内容,然而语言层面不知道这个改变(因为文件描述符是OS分配的),所以就造成了输出重定向。
输入重定向
理解输出重定向例子后,我们很容易就能写出输入重定向。
8 int main ()9 {10 11 // 关闭stdin12 close(0);13 int fd = open("log.txt", O_RDONLY);14 if(fd<0)15 {16 perror("open:");17 return 1;18 } 19 printf("fd = %d \n", fd);20 char buffer[128];21 fgets(buffer, sizeof buffer, stdin);22 printf("buffer:%s\n", buffer);23 close(fd);}
运行结果:
可知我们本该需要使用键盘输入的时候,但是却不需要我们输入,而是从我们打开的文件中读取了一行。这就完成了输入重定向工作。
追加重定向
我们实现一直往log.txt追加输出内容的代码:
1 #include<stdio.h>2 #include<string.h>3 #include<unistd.h>4 #include<sys/types.h>5 #include<sys/stat.h>6 #include<fcntl.h>7 8 int main ()9 {10 11 close(1);//将文件打开方式变为追加打开即可12 int fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666); //fd的文件描述符为113 //下面的内容本应该打印到屏幕上。但实际上却没有打印出来。14 printf("打开文件分配的fd为%d\n", fd); 15 printf("打印到屏幕上的内容\n");16 fprintf(stdout, "hello fprintf\n");17 const char* s1 = "hello fwrite\n";18 fwrite(s1, 1, strlen(s1), stdout);19 22 fflush(stdout);23 close(fd);24 return 0;25 }
运行程序前后,log.txt内容确实被追加了!
dup2()系统调用
上面的例子只是让我们见识一下重定向是什么样子。而实际工程中,我们多使用dup2()系统调用,来完成此功能。
把oldfd文件描述符的内容给nwefd(相当于修改的是数组内容)。
看下面代码示例:
8 int main (int argc, char* argv[])9 {10 if(argc!=2)11 {12 return 1;13 }14 15 int fd = open("log.txt", O_CREAT| O_WRONLY|O_TRUNC, 0666);16 printf("fd:%d\n", fd);17 dup2(fd,1); //将stdout的内容修改为fd18 printf("打印屏幕上的内容:%s\n",argv[1]);19 20 close(fd);21 return 0; }
运行结果:
通过上面的例子,我们使用dup2完成了输出重定向!
总结
重定向的本质,其实是在OS内部,更改fd对应的内容指向!!!
重定向很容易解决Linux系统一切皆文件的设计理念。它把显示器、键盘、磁盘当成文件,全部封装成struct file,在用户看来,只需要操作对应的结构体,即可完成重定向的工作。用户根本不需要知道硬件的细节。也恰好能体现封装的思想。
文件缓冲区
-
什么是缓冲区?
缓冲区就是一段内存区域,介于CPU和硬盘之间,因为要执行IO的话,CPU肯定会访问硬盘。CPU的速度是ns级别,硬盘的速度是ms级别。如果让CPU直接访问的话,肯定会拖慢系统的速度。因此我们可以在内存中开辟一小段区域,这段区域就叫做缓冲区。 -
缓冲区有什么用?
缓冲区可以提高效率。
写透模式(wrrite through):CPU直接向硬盘写入(耽误CPU时间,慢)。
写回模式:(write back):CPU将数据写到缓冲区后,就干别的事情去了,让缓冲区自己往硬盘写入,写完报告给CPU即可。(不耽误CPU时间,快,,也可以提高用户的相应速度)。 -
缓冲区的刷新策略
立即刷新(写完就立马刷新)、行刷新/行缓冲(遇到\n就立马刷新)、满刷新/全缓冲(写满缓冲区才刷新)。
一般而言,行缓冲的设备文件:显示器;全缓冲的设备:磁盘文件
深入理解缓冲区的概念
下面我们先看一段代码:
8 int main ()9 {10 11 //C语言提供的12 printf("hello world\n");13 const char* s1 = "hello frite\n";14 fwrite(s1, 1, strlen(s1), stdout);15 fprintf(stdout,"hello fprintf\n");16 17 //OS系统提供的接口18 const char *s2 = "hello write\n";19 write(1, s2, strlen(s2));20 21 22 fork(); 23 return 0;24 }
程序运行结果如下:
**观察发现,程序运行时是正常的,但是当我们重定向到文件里面后,发现C语言提供的函数打印了两次,而系统调用函数只打印一次。**如果我们把fork去掉之后,程序正常运行。我们猜想,这种情况一定和fork有某种关系。
解释:
- 如果向显示器打印,刷新策略是行刷新,那么最后执行fork的时候,一定是函数执行完了同时数据已经被刷新了,此时再fork就没有意义了。
- 如果对应的程序进行了重定向,要向磁盘文件打印,隐形的刷新策略变成了全缓冲(\n便不管用了),fork的时候,一定是函数已经执行完了,但是数据还没有刷新!因为刷新会清空缓冲区,这涉及到写时拷贝,当父进程结束运行,会刷新缓冲区,同时触发写时拷贝,赋值给子进程,子进程退出时再刷新一份,这样就相当于打印了两次。
- 为什么系统调用函数只打印一次呢?
原因是,我们上面提到的缓冲区其实是C语言层面上的,调用C函数时,会将数据写到C提供的缓冲区上。而fork后,出发写时拷贝时,父进程刷新数据到OS缓冲区(1份),子进程刷新到OS缓冲区(2份),因此C语言层面上会打印两次。而write系统调用会直接将数据写到OS缓冲区,因为他是系统提供的函数,不属于C语言函数,因此不涉及C语言层面上的写时拷贝动作,因此只会刷新一次。
下图解释了这种现象:
输出缓冲区部分代码解释
我们在输出缓冲区,当时红色框框的代码没有讲解,现在我们可以解释一下:
- 当我们关闭了1号文件,打开了log.txt,此时log.txt的文件描述符为1.
- 刷新策略由行刷新,变成了普通刷新,因为是往文件里打印,因此我们输出的数据,其实是在stdout的缓冲区里,并没有刷新呢!
- 如果我们提前关闭close(1),因为数据还在缓冲区里,还没有来得及刷新到文件里。所以log.txt文件里什么都没有。
- 当我们提前fflush文件的时候,已经把数据刷新到文件里,因此再关闭文件就没事了。
总结
所有的设备按道理来说,都倾向于全缓冲,缓冲区满了,才刷新,这样能进行更少的IO操作,提高效率。因为和外设IO时,数据量的大小不是主要矛盾,和外设预IO的过程(准备过程)是最耗费时间的。
为了照顾到用户体验,显示器一般都是行刷新。极端情况下,我们也可以自定义刷新规则。
**C语言的缓冲区在哪里呢?**和fd一样,存在FILE结构体里面,包含了该文件fd对应的语言层的缓冲区结构。
stdout和stderr的区别
stdout和stderr所对应的硬件都是显示器,但是他们具体有什么区别呢?
名字上:stdout叫标准输出流,stderr叫标准错误流。
让我们看下面一段代码:
该程序输出的1表示使用stdout打印的。输出2表示使用stderr打印的。
1 #include<iostream>2 #include<stdio.h>3 4 int main()5 {6 //stdout -> 17 printf("hello printf 1\n");8 fprintf(stdout, "hello fprintf1\n");9 10 //stderr11 perror("hello perror 2");12 13 // cout -> 114 std::cout<< "hello cout 1"<<std::endl;15 //cerr -> 2 16 std::cerr<<"hello cerr 2"<<std::endl;17 18 return 0;19 }
程序首先都被打印到了屏幕上,证明他们对应的硬件都是显示器。
我们在此程序的基础上,运行下面的命令:
重定向后,发现stderr的输出仍然打印出来了,但是stdout的输出被重定向到log.txt。
结论:因为屏幕只有一个,stdin和stdout都打开了显示器文件,即一个显示器文件被打开了两次,有两个文件描述符,输出重定向只是重定向了fd=1描述符,并没有影响到stderr。因此stderr仍然打印到屏幕上。
应用:
//运行下面的命令即可把两种输出,分别重定向到两个文件里。./myfile > log.txt 2>err.txt
//运行下面的命令即可把两种输出,重定向到一个文件里。./myfile > log.txt 2>&1
总结
一般而言程序如果可能出问题的话,使用stderr或者cerr来打印。
如果是常规文本的打印,建议使用cout或者stdout打印。
自己实现一个perror
在我们的文件操作函数出错之后,出错信息一般都会存在一个全局变量,errno里面,我们一般都使用perror函数来打印错误信息,但是该接口不需要errno。说明该接口一定封装了errno。代码如下:
5 void myperror(const char* s)6 {7 //使用errno全局变量打印错误8 fprintf(stderr, "%s %s\n",s, strerror(errno));9 }
文件系统
文件系统顾名思义是管理文件的系统。如下图是Linux ext2文件系统的磁盘文件系统图。
磁盘是典型的块设备,硬盘分区被划分为一个个的block。一个block的大小是格式化的时候确定的,并且不能更改。其中启动块(Boot Block)的大小是确定的。
- Block Group:块组,文件系统会根据分区的大小划分为好多个Block Group。而每个Block Group有着相同的结构。
- 超级块(Super Block):存放(整个)文件系统本身的结构信息。记录的主要信息有:block和inode的总量,未使用的block和inode的数量,一个block和inode的大小,最近一次挂载的时间,最近一次写入数据的时间,最近一次检查磁盘的时间等其他文件系统的相关信息。Super Block如果被损坏,整个文件系统就被破坏了。因此,有好多个Block Group都有Super Block。
- GDT(Group Descriptor Table):块组描述符,描述块组的属性信息,这个块组多大,已经使用了多少,有多少inode,已经占用了多少,还剩多少,一共有多少个block,使用了多少。
- 块位图(Block Bitmap):位图中记录着哪个数据块已经被占用,哪个数据块没有被占用。
- inode位图(inode Bitmap):每个bit表示一个inode是否空闲可用。
- inode Table:i结点表,存放文件属性和文件大小,所有者,最近修改时间等。
- Data blocks:数据区存放文件内容。
众所周知:文件 = 属性 + 数据,因此flie = inode Table + Data blocks
inode
inode是一个结构体,存放着文件的各种属性。
struct inode
{//文件大小//文件的inode编号//其他属性int blocks[15] //(0-11是直接索引,12-15是间接索引)
}
- inode与文件名的关系:我们使用文件名去寻找文件,但是linux其实并不认识文件名,它只认识inode号,因此,在每个目录下面<文件名,inode>都有着对映的键值对,可以帮助转化成inode。
- 目录也是文件,也有ionde号,也有data Block。
因此对于一个目录,进入目录需要X(执行)权限,创建文件需要W(写)权限(要写数据块),显示文件名与属性r(读)权限(要读数据块)。
创建文件过程:首先os申请一个inode号,并且为之分配一个数据块,然后更新inode表。完成之后,更新目录的data block。
发现系统还有空间,为什么不能创建文件?
因为inode和data block是固定的。可能是没有ionde号了。
软硬链接
- 硬链接是通过inode引用另外一个文件,引用计数+1,inode号相同,相当于共享一个inode。
- 软链接是通过名字引用另外一个文件,引用计数不变,新inode号,相当于一个新的inode号指向老的inode号,相当于快捷方式。