【Linux】内存文件系统的I/O、重定向

文章目录

在这里插入图片描述

1. 系统中的文件

在学习完Linux权限后，我们清楚的知道：

文件 = 文件内容 + 文件属性

，这和进程就很像。所以我们文件的所有操作无非就是对文件内容或属性进行的。

无论何种语言，在访问文件之前，我们都必须打开文件，例如C语言中的fopen。但是我们访问前为什么要打开它呢？

文件在没有被访问的时候，它存储在磁盘上。学习完进程后，我们清楚的知道，访问文件其实是进程在访问。

在下面的代码中，当程序跑起来，进程执行到fopen时，文件才被打开。
在这里插入图片描述
进程是在内存中的，最终要被CPU执行；

当进程执行文件操作时，但文件在磁盘上，根据冯诺依曼体系，CPU不能访问磁盘。

所以，文件也必须加载到内存中，否则进程访问不了（因为CPU访问不了），所以，打开文件的本质是：将文件加载到内存中。

因为文件 = 内容 + 属性，所以加载时，加载的就是文件的内容或属性。

我们知道一个进程可以打开多个文件，多个进程就可以打开更多的文件。
既然操作系统要管理进程，那么操作系统也要管理加载到内存中的文件（文件是谁加载的？什么时候加载的?要不要释放？…），操作系统管理加载到内存中文件的方式：先描述，再组织！

因此，我们研究打开的文件，是在研究：进程和文件的关系！

文件就可以分为：

被打开的文件 - -内存中
未被打开的文件 - - 磁盘中

2. 回顾C中的文件接口

在C语言中，我们学习了很多的文件相关接口，例如：
在这里插入图片描述
在系统文件中，我们重点关注 w 与 a

在这里插入图片描述
执行任何一个程序，进程默认会打开三个输入输出流，分别是stdin, stdout, stderr。

仔细观察发现，这三个流的类型都是FILE，而且fopen的返回值也是FILE。

在任何一个语言中，都会提供类似的三个流，既然语言都支持，那这本身并不属于语言的特性，而是属于操作系统所做的工作。

所以各种语言提供的访问文件（键盘、显示器）的接口，本质都是封装的文件类的系统调用接口。

3. 文件类的系统调用

3.1 open

在这里插入图片描述

参数

第二个参数是标记位，上方列出了常用的选项，它们本质上都是宏，可以组合使用。

但是以前使用多个宏时，我们需要传递多个参数，为什么这里一个int flag就能解决呢？- - -

位图，32个比特位，可以存储32个选项

。如果是这样的话，那上方列出的宏选项，它们应该只有一个比特位为1。

举个栗子：
在这里插入图片描述
上方代码就通过检查flag对应位置上是0还是1，就可以实现传递多个选项的效果。

下面我们使用一下系统调用open
在这里插入图片描述

运行后发现，文件不存在时确实创建了，但是文件的权限为什么是错乱的呢？

因为创建文件和起始权限是操作系统的两个分支功能，操作系统不会在系统调用上让你创建文件时就按照默认权限来，它也没有这个权力。你要告诉系统调用，文件的默认起始权限是什么。

我们需要通过第三个参数mode指定，这不就是权限那里的chmod吗？

在这里插入图片描述

权限不是666是因为有 umask，去除umask可在函数中调用 umask(0);
每个进程都有自己的umask，继承自系统，如果你设置了umask，它采用就近原则使用用户设置的，不使用系统的了。

有了open，我是不是就可以自己实现一个touch命令了。

如果是touch命令，则获取命令行中的第二个参数，调用open(argv[1]，O_WRONLY | O_CREAT，0666)
不重新设置umask时，文件权限就是664

返回值

在这里插入图片描述
打开并新建一个文件后，会返回新文件的文件描述符descriptor

上方的代码返回的文件描述符为什么是3呢？- - 后面讲
它有什么用呢？

在这里插入图片描述

使用文件描述符可对文件进行操作
在这里插入图片描述

修改要写入的内容后
在这里插入图片描述

为什么此时写到文件中的内容，没有清空之前的内容呢？ - - （因为你只告诉open系统调用，只写，没有就创建，没告诉我要清空。）

清空/截断

的选项：

O_TRUNC

，带上该选项，写入前就会清空。
在这里插入图片描述

新增

式的写，需要带上选项：

O_APPEND

有了上面的知识后，我们就可以清楚的知道：fopen -> open，fclose -> close，fwrite->write，fread -> read；w、a、r就对应相应的宏，所以语言层的文件库函数，本质上就是封装了文件的系统调用接口。

3.2 文件描述符

在这里插入图片描述

open的返回值（文件描述符）为什么从3开始呢？

Linux进程默认情况下会有3个缺省打开的文件描述符，分别是标准输入0，标准输出1，标准错误2

。 0,1,2对应的物理设备一般是：键盘，显示器，显示器

那么此时就可以直接使用三个默认打开的文件描述符了

#include<stdio.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>#include<string.h>intmain(){char buf[1024];ssize_t s =read(0, buf,sizeof(buf));//从标准输入中读if(s >0){
         buf[s]=0;write(1, buf,strlen(buf));//输入到标准输出中}return0;}

所以这个文件描述符到底是什么呢？- - 连续的数字，是数组下标吗？

下面我们从内核的角度看一下
在这里插入图片描述

内核源代码中确实存在文件描述符表
在这里插入图片描述

所以，每次我们在open时，当前进程会去自己的文件描述符表中的结构体指针数组中从前向后找空位置。

那么，在系统层面，文件描述符就是访问文件的唯一方式。

但是我们平常在使用C标准库提供的文件访问函数时，并没有看到相应的fd呀？- - 这是因为库中进行了封装，全部封装到FILE中去了！
在这里插入图片描述

上面所说的我都能理解，可是键盘、显示器也能被当作文件来看吗？Linux下一切皆文件又如何理解呢？

对于硬件来说，它们都有一个特点，它们统一叫做外设。操作系统是通过类似于链表的方式将各个外设管理起来的。
在这里插入图片描述

但对于很多外设(struct device)来说，它们的属性可以相同，但是属性的内容可以不同；可是键盘就是键盘、显示器就是显示器，对这两个外设进行操作的方法只有两个：读和写（IO），所以它们的方法一定不同，因为不同的设备访问对应硬件的方式是不同的。那是怎么做到统一以文件的视角来访问的呢？

对于每一种设备，都要给其定义读写方法。例如：键盘定义了读和写的方法，但是只需要实现读方法；显示器定义了读和写的方法，但是只需要实现写方法。对于未实现的方法，就让它为空。

在对设备进行管理时，只需要在其struct file中设置两个函数指针，让其指向对应的方法（不关心方法的实现）,屏蔽了底层的差异。

从struct file向上开始，所有访问硬件的方法，统一叫做读和写，struct file就相当于做了一次封装。

Linux系统对外部只需要提供struct file对象，这叫做虚拟文件系统vfs。

那这个struct file是怎么让用户看到的呢？通过文件描述符，让进程看到。 - 因为所有用户的行为，都会被转化为进程- 站在进程角度，它只需要通过fd，找到对应的struct file，执行struct file中对应的方法即可完成对设备的操作。所以Linux中一切皆文件是对进程而言的

在一个结构体当中，一切皆文件，但是底层却有不同硬件，这种模式在C++ 中叫做多态。（struct file就是父类，因为struct file都一样；硬件的struct device就是子类，子类实现了不同的读写方法；继承就是产生了上下层关系），这就是C语言中实现多态的一种形式。

内核源代码
在这里插入图片描述

4. IO的基本过程

写文件

其实write做的工作就是将要写的内容，拷贝到文件的内核缓冲区即可。

读文件

先从磁盘读到文件的内核缓冲区，在调用read函数拷贝到指定位置

修改文件

修改的本质：也是

先读取，在写入

（先将文件加载到文件的内核缓冲区，在内核中修改，然后再将修改后的内容从缓冲区加载到外设中）

存在缓冲区的原因：内存的操作快，外设的操作慢

5.重定向

5.1 引入重定向

先看一个现象
在这里插入图片描述
为什么关掉0以后，我自己打开的文件就是0了呢？

因为进程打开文件，需要给进程分配新的fd，

fd的分配规则：最小的，没有被使用的fd！

会从上往下扫描文件描述符表，找未被使用的，最小的。

如果我把1号关了，此时fd1就应该为1；由于printf底层封装了fprintf，fprintf中有FILE*参数，默认fd为1，所以只会向1号描述符中打印，不管1指向哪里，那么就应该将内容打印到log1.txt中！

在这里插入图片描述
但是log1.txt中怎么什么都没有呢？

fflush(stdout)后为什么又有了呢？ - - 跟缓冲区相关，后面讲。

为什么本来应该向显示器中打印的内容，最终却写到了文件中呢？
因为在上层的调用中，fprintf、fwrite等向stdout中打印的所有调用，它们只认文件描述符1。 1号描述符表并没有变，我们只改变了1中的内容，这就叫做

重定向

所以，重定向的原理就是：更改文件描述符表中特定下标中的内容。重定向的过程中，上层代码毫不知情！

5.2 系统中的重定向接口

dup2：系统重定向接口
在这里插入图片描述
本质就是用新的fd覆盖到指定位置！被覆盖的将被关掉。

输出/追加重定向

在这里插入图片描述

那追加重定向不就是只需要将选项 O_TRUNC换成O_APPEND了吗？

输入重定向

在这里插入图片描述

在写我们自己的shell时，思考一下，程序替换会影响重定向的结果吗？

不会，因为程序替换仅仅是替换进程所对应的代码和数据，必要时修改mm_struct中页表的映射关系。对于一个进程“上层”的东西（task_struct、file_struct、mm_struct等）都不会修改，依旧使用重定向以后的内容。

6. 缓冲区问题

在这里插入图片描述
在上面的内容中，我们遗留了一个问题。
那就是为什么我重定向以后它并没有直接给我写到指定文件中，而fflush(stdout)后就写进去了呢？

首先我们要知道，在C语言中我们使用的printf、scanf、fprintf、fscanf、fwrite、fread等都要求有一个FILE*的指针。

所以，在调用这些函数进行操作时，它并没有直接调用系统调用read、write直接拷贝到文件的内核缓冲区，因为频繁的调用系统调用的成本太高了，效率低。

所以怎么能提高效率呢？

通过用户级缓冲区！！你printf、fprintf等只需要将内容拷贝到用户级缓冲区中任务就完成了，无非就是在拷贝的过程中进行一下格式化；等用户级缓冲区攒了足够多的数量，在统一调用系统调用写入到文件的内核缓冲区，提高了效率。

该缓冲区在FILE结构体中，刷新的本质就是从用户级缓冲区拷贝到内核的文件缓冲区。

用户级缓冲区有以下几种刷新方案：

显示器文件：行刷新
普通文件：缓冲区写满再刷新
不缓冲（语言级无需刷新）

我们将最开始的代码修改一下会发现，如果我不调用任何的close或者调用fclose，内容可以正常打印出来，这是为什么呢？
在这里插入图片描述
因为，当一个进程退出的时候，会自动刷新自己的缓冲区（所有的FILE对象内部，包括stdin、stdout、stderr）；fclose是C语言级的，调用它关闭FILE时，也会自动刷新。

那close(fd)后，为什么不会刷新呢？
在这里插入图片描述
此时尽管“表面上”是向显示器中打，应该是行刷新，那么我不自己刷新应该也可以显示出来呀？ - - 此时不是行刷新，因为显示器文件早就关闭了，1中放的是普通文件，应执行写满刷新的策略。

那操作系统是什么时候将文件内核缓冲区的内容刷新到外设中的呢？我能不能控制呢？

通过系统调用fsync

一个简单的题目

在这里插入图片描述
如果在调用函数时不加 \n，即使不重定向，也是上图所示的打印效果。

7. 简单版shell的实现

#include<cstdio>#include<stdlib.h>#include<string>#include<string.h>#include<unistd.h>#include<sys/wait.h>#include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>usingnamespace std;constint basesize =1024;constint argvnum =64;constint envnum =64;//存储命令行参数的两个全局变量char* g_argv[argvnum];int g_argc;//存shell自己的环境变量char* g_env[envnum];//如果这两个设置为局部变量，则会写入一个空白//局部变量销毁，环境变量表中存的是这两个变量的地址，所以就是空char pwd[basesize];char pwdenv[basesize];//存储之前的退出码int lastcode =0;//重定向相关全局变量#defineNonRedir0#defineInputRedir1#defineOutputRedir2#defineAppendRedir3int redir = NonRedir;char* filename =nullptr;//去除空格#defineTrimSpace(pos)\do{\while(isspace(*pos)){\pos++;\}\}while(0)\

string GetName(){
    string username =getenv("USER");return username.empty()?"None": username;}

string GetHostName(){
    string hostname =getenv("HOSTNAME");return hostname.empty()?"None": hostname;}boolrepalcePwd(){for(int i =0; g_env[i]; i++){if(strncmp(g_env[i],pwdenv,3)==0){
            g_env[i]= pwdenv;returntrue;}}returnfalse;}

string GetPwd(){if(getcwd(pwd,sizeof(pwd))==nullptr)return"Node";//将当前的工作路径，保存至环境变量中snprintf(pwdenv,sizeof(pwdenv),"PWD=%s",pwd);//putenv(pwdenv); //将新的pwd,添加到系统的环境变量表中repalcePwd();//将新的pwd,添加到自己的环境变量表中return pwd;// string pwd = getenv("PWD");}

string LastDir(){
    string pwd =GetPwd();if(pwd =="/"|| pwd =="None")return pwd;//寻找最后一个文件夹int pos = pwd.rfind("/");return pwd.substr(pos+1);}//1.显示命令行提示符voidShowCommandLine(){char command_line[basesize];snprintf(command_line,basesize,"[%s@%s %s]#",\
            GetName().c_str(),GetHostName().c_str(),LastDir().c_str());printf("%s",command_line);fflush(stdout);}//2.读取命令行参数boolGetCommandLine(char command_buffer[],int size){//读取一行的用户输入char* ret =fgets(command_buffer,size,stdin);if(ret ==NULL){returnfalse;//获取输入失败}//处理回车键
    command_buffer[strlen(command_buffer)-1]='\0';if(strlen(command_buffer)==0)returnfalse;returntrue;}voiddebug(){printf("argc:%d\n",g_argc);for(int i=0; g_argv[i]; i++){printf("[%d] = %s\n",i,g_argv[i]);}}voidCheckRedir(char command_line[],int len){int end = len -1;while(end >=0){if(command_line[end]=='<'){
            redir = InputRedir;
            command_line[end]='\0';
            filename =&command_line[end+1];//过滤空格TrimSpace(filename);break;}elseif(command_line[end]=='>'){if(command_line[end -1]=='>'){
                redir = AppendRedir;
                command_line[end]='\0';
                command_line[end-1]='\0';
                filename =&command_line[end+1];//过滤空格TrimSpace(filename);break;}else{
                redir = OutputRedir;
                command_line[end]='\0';
                filename =&command_line[end+1];//过滤空格TrimSpace(filename);break;}}else{
            end--;}}}voidInitCommand(){//命令行清空memset(g_argv,0,sizeof(g_argv));
    g_argc =0;//每次检查是否有重定向前先清空
    redir = NonRedir;
    filename =nullptr;}voidAnalyCommand(char command_line[]){constchar sep[10]=" ";//指定分隔符
    g_argv[g_argc++]=strtok(command_line,sep);//先提取第一个//strtok读取失败返回nullwhile((g_argv[g_argc++]=strtok(nullptr,sep)));//依次提取后面的
    g_argc--;//个数要-1}voidAnalyzeCommandLine(char command_line[]){InitCommand();//printf("redir before:%s\n",command_line);//检查重定向CheckRedir(command_line,strlen(command_line));// printf("redir:%d\n",redir);// printf("filename:%s\n",filename);// printf("redir after:%s\n",command_line);AnalyCommand(command_line);}voidRedir(){//程序替换不会影响重定向，因为内核数据结构中的file_struct没变//程序替换，替换的是代码和数据。int fd =-1;if(redir == InputRedir){if(filename){
            fd =open(filename,O_RDONLY);if(fd <0){exit(3);}dup2(fd,0);}else{exit(2);}}elseif(redir == OutputRedir){if(filename){
            fd =open(filename,O_CREAT | O_WRONLY | O_TRUNC,0666);if(fd <0){exit(5);}dup2(fd,1);}else{exit(4);}}elseif(redir == AppendRedir){if(filename){
            fd =open(filename,O_WRONLY | O_CREAT | O_APPEND,0666);if(fd <0){exit(7);}dup2(fd,1);}else{exit(6);}}else{//没有重定向//do nothing}}boolExecCommandLine(){//shell创建子进程执行任务
    pid_t id =fork();if(id <0)returnfalse;if(id ==0){//child执行命令//重定向应由子进程做Redir();execvpe(g_argv[0],g_argv,g_env);exit(1);//执行失败，退出码为1}int status =0;
    pid_t rid =waitpid(id,&status,0);//阻塞式等待if(rid >0){//等待成功//1.子进程正常结束if(WIFEXITED(status)){
            lastcode =WEXITSTATUS(status);}else{
            lastcode =99;}returntrue;}returnfalse;}voidAddEnv(constchar* str){int index =0;while(g_env[index]){
        index++;}
    g_env[index]=(char*)malloc(strlen(str)+1);strncpy(g_env[index++],str,strlen(str)+1);
    g_env[index]=nullptr;}boolCheckAndExecBuildCommand()//判断是否式内建命令{//枚举几个内建命令if(strcmp(g_argv[0],"cd")==0){if(g_argc ==2){chdir(g_argv[1]);
            lastcode =0;}else{
            lastcode =1;}returntrue;}elseif(strcmp(g_argv[0],"export")==0){if(g_argc ==2){AddEnv(g_argv[1]);
            lastcode =0;}else{
            lastcode =2;}returntrue;}elseif(strcmp(g_argv[0],"env")==0){for(int i =0; g_env[i]; i++){printf("%s\n",g_env[i]);}
        lastcode =0;returntrue;}elseif(strcmp(g_argv[0],"echo")==0){if(g_argc ==2){if(g_argv[1][0]=='$'){if(g_argv[1][1]=='?'){printf("lastcdoe:%d\n",lastcode);
                    lastcode =0;}}else{printf("%s\n",g_argv[1]);
                lastcode =0;}}else{
            lastcode =3;}returntrue;}returnfalse;}voidInitEnv(){externchar** environ;//从系统shell中获取环境变量int index =0;while(environ[index]){int len =strlen(environ[index]);
        g_env[index]=(char*)malloc(len +1);strncpy(g_env[index],environ[index],len +1);
        index++;}
    g_env[index]=nullptr;}intmain(){InitEnv();char command_buffer[basesize];while(true){//1.显示命令行提示符ShowCommandLine();//slsleep(2);//printf("\n");//2.读取命令行参数if(!GetCommandLine(command_buffer,basesize)){continue;}//3.解析命令行参数AnalyzeCommandLine(command_buffer);//debug();if(CheckAndExecBuildCommand())//判断是否式内建命令{continue;}//4.执行命令ExecCommandLine();}return0;}

标签： linux 服务器

本文转载自: https://blog.csdn.net/weixin_69380220/article/details/142913354
版权归原作者 戴墨镜的恐龙 所有，如有侵权，请联系我们删除。

【Linux】内存文件系统的I/O、重定向

文章目录

1. 系统中的文件

2. 回顾C中的文件接口

3. 文件类的系统调用

3.1 open

3.2 文件描述符

4. IO的基本过程

5.重定向

5.1 引入重定向

5.2 系统中的重定向接口

6. 缓冲区问题

7. 简单版shell的实现

发表评论

“【Linux】内存文件系统的I/O、重定向”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航