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>
 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的实现

#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;
}