文章目录
- [1. 系统中的文件](#1. 系统中的文件)
- [2. 回顾C中的文件接口](#2. 回顾C中的文件接口)
- [3. 文件类的系统调用](#3. 文件类的系统调用)
-
- [3.1 open](#3.1 open)
- [3.2 文件描述符](#3.2 文件描述符)
- [4. IO的基本过程](#4. IO的基本过程)
- 5.重定向
-
- [5.1 引入重定向](#5.1 引入重定向)
- [5.2 系统中的重定向接口](#5.2 系统中的重定向接口)
- [6. 缓冲区问题](#6. 缓冲区问题)
- [7. 简单版shell的实现](#7. 简单版shell的实现)
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对应的物理设备一般是：键盘，显示器，显示器
那么此时就可以直接使用三个默认打开的文件描述符了
c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
int main()
{
char buf[1024];
ssize_t s = read(0, buf, sizeof(buf));//从标准输入中读
if(s > 0)
{
buf[s] = 0;
write(1, buf, strlen(buf));//输入到标准输出中
}
return 0;
}所以这个文件描述符到底是什么呢？- - 连续的数字，是数组下标吗？
下面我们从内核的角度看一下
内核源代码中确实存在文件描述符表
所以，每次我们在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的实现
cpp
#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>
using namespace std;
const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;
//存储命令行参数的两个全局变量
char* g_argv[argvnum];
int g_argc;
//存shell自己的环境变量
char* g_env[envnum];
//如果这两个设置为局部变量，则会写入一个空白
//局部变量销毁，环境变量表中存的是这两个变量的地址，所以就是空
char pwd[basesize];
char pwdenv[basesize];
//存储之前的退出码
int lastcode = 0;
//重定向相关全局变量
#define NonRedir 0
#define InputRedir 1
#define OutputRedir 2
#define AppendRedir 3
int redir = NonRedir;
char* filename = nullptr;
//去除空格
#define TrimSpace(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;
}
bool repalcePwd()
{
for(int i = 0; g_env[i]; i++)
{
if(strncmp(g_env[i],pwdenv,3) == 0)
{
g_env[i] = pwdenv;
return true;
}
}
return false;
}
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.显示命令行提示符
void ShowCommandLine()
{
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.读取命令行参数
bool GetCommandLine(char command_buffer[],int size)
{
//读取一行的用户输入
char* ret = fgets(command_buffer,size,stdin);
if(ret == NULL)
{
return false; //获取输入失败
}
//处理回车键
command_buffer[strlen(command_buffer) - 1] = '\0';
if(strlen(command_buffer) == 0)
return false;
return true;
}
void debug()
{
printf("argc:%d\n",g_argc);
for(int i=0; g_argv[i]; i++)
{
printf("[%d] = %s\n",i,g_argv[i]);
}
}
void CheckRedir(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;
}
else if(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--;
}
}
}
void InitCommand()
{
//命令行清空
memset(g_argv,0,sizeof(g_argv));
g_argc = 0;
//每次检查是否有重定向前先清空
redir = NonRedir;
filename = nullptr;
}
void AnalyCommand(char command_line[])
{
const char sep[10] = " ";//指定分隔符
g_argv[g_argc++] = strtok(command_line,sep);//先提取第一个
//strtok读取失败返回null
while((g_argv[g_argc++] = strtok(nullptr,sep)));//依次提取后面的
g_argc--;//个数要-1
}
void AnalyzeCommandLine(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);
}
void Redir()
{
//程序替换不会影响重定向，因为内核数据结构中的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);
}
}
else if(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);
}
}
else if(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
}
}
bool ExecCommandLine()
{
//shell创建子进程执行任务
pid_t id = fork();
if(id < 0)
return false;
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;
}
return true;
}
return false;
}
void AddEnv(const char* 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;
}
bool CheckAndExecBuildCommand() //判断是否式内建命令
{
//枚举几个内建命令
if(strcmp(g_argv[0],"cd") == 0)
{
if(g_argc == 2)
{
chdir(g_argv[1]);
lastcode = 0;
}
else
{
lastcode = 1;
}
return true;
}
else if(strcmp(g_argv[0],"export") == 0)
{
if(g_argc == 2)
{
AddEnv(g_argv[1]);
lastcode = 0;
}
else
{
lastcode = 2;
}
return true;
}
else if(strcmp(g_argv[0], "env") == 0)
{
for(int i = 0; g_env[i]; i++)
{
printf("%s\n",g_env[i]);
}
lastcode = 0;
return true;
}
else if(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;
}
return true;
}
return false;
}
void InitEnv()
{
extern char** 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;
}
int main()
{
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();
}
return 0;
}