【从浅学到熟知Linux】基础IO第二弹=＞输入输出重定向及其原理、用户级缓冲区、如何理解一切皆文件（含dup2系统调用详解）

🏠关于专栏：Linux的浅学到熟知专栏用于记录Linux系统编程、网络编程等内容。
🎯每天努力一点点，技术变化看得见

---

访问文件的本质

操作系统上会打开大量的文件，当进程打开一个文件时，操作系统会在内核为该文件创建一个struct file结构体，该结构体包含文件存储在磁盘的位置、文件大小、权限、引用计数、下一个struct file的地址等。操作系统通过维护struct file队列，即可对文件进行管理。

当进程需要访问文件时，会在进程的文件描述符表中选择下标最小的位置（文件描述符表中每个元素的类型均是struct file*类型），让它指向对应的文件的struct file，并给该文件的struct file的引用计数加1。

如果多个进程访问同一份文件时，操作系统只会给同一个文件创建一个struct file。假设有3个进程同时访问log.txt，则操作系统只会维护一份log.txt的struct file。每当一个进程与log.txt产生关联（打开该文件），则会将该文件的struct file中的引用计数加1。

如果进程关闭某个文件，则会将该文件与进程的文件描述符表去关联（即将原本指向该文件的文件描述符表的下标位置置空），并将对应文件的struct file引用计数减1。当引用计数为0时，表示没有任何进程使用该文件，则该文件的struct file及其存储信息将被删除。

重定向

重定向原理

当我们使用命令echo "jammingpro"时，会在屏幕上打印"jammingpro"；但如果我们使用echo "jammingpro" > log.txt，则会将原本应该打印到显示器上的内容打印到log.txt。像这种情况，被称为重定向。

★ps：echo "jammingpro" > log.txt是覆盖式的输出重定向，而echo "jammingpro" >> log.txt追加式的输出重定向，不会覆盖文件中原本的内容。如果cat < log.txt则是输入重定向，cat会在显示器中打印log.txt的内容

如果我们将标准输出（stdout）的文件描述符（1号文件描述符）关闭，再打开一个新的文件。由于当前系统中的0号标准输入、2号标准错误均被占用，根据文件描述符分配规则（分配当前最小的未使用的描述符），故该新文件的文件描述符则是1号。

此时我们使用printf向stdout打印时，则会向1号描述符打印的内容，这些内容将被打印到新打开的文件中↓↓↓

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>

int main()
{
	close(1);
	
	int fd = open("./log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
	int cnt = 10;
	while(cnt)
	{
		printf("fd->%d\n", fd);
		cnt--;
		sleep(1);
	}
	
	return 0;
}

执行该程序后，我们使用while :; do cat log.txt; echo "-----------------"; sleep 1; done;每隔1秒读取log,txt一次。

上面结果中，没什么不是每间隔1秒，向log.txt中写入一条"fd->1"呢？而是前10秒没有向文件写入，到最后程序退出才刷新呢？由于printf中维护了一个缓冲区，当检测到1号描述符对应的是显示器时，它会采用行缓冲的方式进行刷新，即遇到\n或缓冲区满时，会将缓冲区的内容刷新到显示器。但如果检测到1号描述符对应的不是显示器，则不会启动行缓冲功能，即不会自动刷新缓冲区。此时如果我们手动调用fflush(stdout)，则可以将printf缓冲区的内容写入到文件中。↓↓↓

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>

int main()
{
	close(1);
	
	int fd = open("./log.txt", O_WRONLY | O_CREAT | O_TRUNC, 0666);
	int cnt = 10;
	while(cnt)
	{
		printf("fd->%d\n", fd);
		cnt--;
		fflush(stdout);
		sleep(1);
	}
	
	return 0;
}

现在，每次打印后，printf缓冲区的内容会被立即写入log.txt，故我们看到的结果是，每隔一秒，文件多一条"fd->1"。

从上面可知，重定向原理是：如果程序原本应该向1号文件描述符中打印内容，此时将1号描述符的文件关闭，并创建一个新文件，新文件的文件描述符被分配为1；此时，原本应该打印到被关闭文件中的内容，打印到了新打开的文件中，这就是重定向。

dup2系统调用

但上面需要将旧文件关闭，再将新文件打开，这样的操作有些许繁琐。系统提供了dup2系统调用，该接口可以实现文件的重定向问题。如果我们希望将1号描述符被3号替换（即把输出到1号描述符的内容输出到3号 或 从1号读取内容变为从3号读取），则可以使用dup2(3, 1)。dup2会将newfd的文件描述符重定向为oldfd文件描述符所指向的文件，并将newfd关闭。

现在，我们尝试打开一个文件，并将输出内容重定向到该文件中↓↓↓

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
	int fd = open("log.txt", O_WRONLY | O_TRUNC | O_CREAT, 0666);
	dup2(fd, 1);//输出重定向
	printf("jammingpro\n");
	printf("xiaoming\n");
	fflush(stdout);
	return 0;
}

接下来，我们实现一个输入重定向，让log.txt中内容作为输入，将log.txt中的所有内容打印到显示器中↓↓↓

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
	int fd = open("log.txt", O_RDONLY);
	dup2(fd, 0);//输入重定向
	char buffer[1024];
	read(0, buffer, sizeof(buffer));
	printf("%s", buffer);
	return 0;
}

C语言FILE结构体与缓冲区

因为C语言IO相关函数与系统调用接口是对应的，且相关库函数是对系统调用的封装，所以本质上，C语言层面访问文件就是通过fd（文件描述符）访问的。故C语言中的FILE结构体内部，必定封装了fd（文件描述符）。

★ps：FILE对象属于用户呢？还是操作系统呢？语言层面的结构都属于用户层，调用fopen会自动malloc(FILE)。

下面我们来研究一段代码↓↓↓

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
	const char* msg1 = "printf\n";
	const char* msg2 = "fprintf\n";
	const char* msg3 = "fwrite\n";
	const char* msg4 = "write\n";
	
	printf("%s", msg1);
	fprintf(stdout, "%s", msg2);
	fwrite(msg3, strlen(msg3), sizeof(char), stdout);
	write(1, msg4, strlen(msg4));

	fork();
}

程序执行结果如下↓↓↓

但如果是使用输出重定向呢？↓↓↓

从上面结果可以看出，如果向屏幕输出，则每个打印语句均打印一次。但如果将结果重定向到文件中，除了操作系统提供的系统调用write打印一次，余下C语言接口均打印两次，这是为什么呢？

C语言的printf、fprintf、fwrite库函数自带缓冲区，这些接口在向目标位置打印数据时，先将数据保存到缓冲区中。当输出对象是显示器时，它们是行缓冲的，即当遇到\n时就会刷新；但如果输出对象是文件，则是全缓冲的，即缓冲区满了才会刷新（或程序退出才会刷新）。

当发生重定向到普通文件时，数据的缓冲方式由行缓冲变为全缓冲。而我们放到缓冲区的数据并不会被立即刷新。由于上述程序输入到缓冲区的内容较少，不会出现缓冲区满的情况，故只有当进程退出后，会统一刷新到文件中。

但fork后，如果父子进程其中一个对缓冲区进行刷新（缓冲区也是数据），则会发生写时拷贝。所以当父进程准备刷新（情况缓冲区）的时候，就会发生写时拷贝，父子进程也就有了同样的一份数据（即缓冲区在父子进程各保存一份）。父子进程分别刷新一次，故C库函数会被打印两次。而write没有变化，说明没有所谓的缓冲区。

综上，printf、fprintf、fwrite库函数会自带缓冲区，而write系统调用没有带缓冲区。另外，我们这里所说的缓冲区都是用户级缓冲区，该缓冲区的存在是为了提升整机性能。

★ps：这里的缓冲区是谁提供的呢？printf、fprintf、fwrite是C语言库函数，而write是系统调用，库函数是系统调用的“上层”，是对系统调用的"封装"，但是write没有缓冲区，而printf、fprintf、fwrite有，足以说明，该缓冲区是二次加上去的，又因为是C语言，所以这个缓冲区是由C语言标准库提供。

缓冲区刷新问题探索
缓冲区刷新分为：

1. 无缓冲——写透模式，直接刷新
2. 行缓冲——不刷新，知道遇到"\n"（常用于显示器刷新）
3. 全缓冲——缓冲区满才刷新（常用于普通文件写入，该缓冲区在进程退出时也会刷新）。

★ps：当进程退出时会刷新缓冲区到指定文件标识符对应的文件中，但如果该文件在进程退出去前已经被关闭，则缓冲区数据无法刷新入指定文件。

缓冲区刷新的本质就是将数据通过write写入到内核。

为什么要有这个缓冲区：

1. 解决效率问题

【例子】在哈尔滨的小明想给远在厦门的夏斌同学邮寄两本Linux黑皮书
如果此时没有快递公司的存在，小明只能骑着他的小三轮，从哈尔滨骑到厦门，这来回可能需要花费一个月。如果此时小明和夏斌家均普及快递，则小明把快递交给快递公司（快递公司等同于缓冲区），快递公司再将哈尔滨到厦门的所有包裹再集中送过去，此时小明不需要再花费大把时间。但快递公司是按装满一麻袋就送过去（类似于行缓冲），还是装满一车才送过去（类似于全缓冲）就取决于快递公司采取的策略了。

操作系统如果刷新数据时，没有缓冲区，则每次存取都需要等待外设将数据存取好，由于外设过慢，将会影响整机效率。但如果此时存在缓冲区，则操作系统将数据存储缓冲区，等存储到一定数量后再刷新到外设，从而减少访问外设的次数，进而提高了效率。

对于操作系统来说，它自己内部也维护了一个内核级缓冲区，用户级缓冲区内容多次刷新到该区域后，系统再将其刷新到外设，进一步减少外设访问此时，以提高访存效率。

2. 配合格式化

当我们在printf("name:%s", username);时，需要使用缓冲区将"name:%s"先存储下来，再读取username并对"name:%s"进行格式化。

下面程序模拟实现行缓冲↓↓↓

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

char buffer[1024];
int pos = 0;
int fd = 0;

void myFlush()
{
	if(buffer[pos - 1] == '\n') write(1, buffer, pos);
	pos = 0;
}

void myPrintf(char* str, int sz)
{
	//这里假设字符串str长度小于1024，并最后一个字符为\n
	strncpy(buffer, str, sz * sizeof(char));
	pos += sz;
	myFlush();
}

int main()
{
	fd = open("log.txt", O_WRONLY | O_CREAT | O_APPEND, 0666);
	dup2(fd, 1);
	char* msg = "Jammingpro\n";
	int cnt = 10;
	while(cnt)
	{
		myPrintf(msg, strlen(msg));
		cnt--;
	}
	write(1, buffer, pos);//进程退出前要刷新缓冲区
	return 0;
}

下面程序是对[Shell基本实现链接]的升级，将在minishell中引入了文件重定向，下方代码中使用注释的方式对新增的代码做出解释↓↓↓

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define SEP " \t"
#define EXIT_CODE 66

#define COM_LEN 1024
#define ARG_LEN 64
#define ENV_LEN 32
#define PWD_LEN 128

//==========新增==========
#define NONE	(1 << 0)
#define INPUT	(1 << 1)
#define OUTPUT	(1 << 2)
#define APPEND	(1 << 3)
int redir = 0;
char* redirFile = NULL;
//========================

char *env[ENV_LEN];
char command[COM_LEN];
char *argv[ARG_LEN];
char pwd[PWD_LEN];
int argc = 0;
int envNum = 0;
int exitcode = 0;

const char* getUser()
{
  return getenv("USER");
}

const char* getPWD()
{
  getcwd(pwd, sizeof(pwd));
  return pwd;
}

const char* getHostName()
{
  return getenv("HOSTNAME");
}

//==========新增==========
void testRedir()
{
  char* start = command;
  int sz = strlen(command);
  while(start < command + sz)
  {
    if(*start == '<')
    {
      redir = INPUT;
      *start = '\0';
      redirFile = start + 1;
      break;
    }
    else if(*start == '>')
    {
      if(start + 1 < command + sz && *(start + 1) == '>')
      {
        redir = APPEND;
        *start = '\0';
        redirFile = start + 2;
        break;
      }
      else
      {
    	redir = OUTPUT;
    	*start = '\0';
    	redirFile = start + 1;
    	break;
      }
    }
    else
    {
      start++;
    }
  }	
}
//========================

void getCommand()
{
  redir = NONE;//新增
  printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getHostName(), getUser(), getPWD());
  char* s = fgets(command, sizeof(command), stdin);
  assert(s != NULL);
  (void)s;
  
  s[strlen(command) - 1] = '\0';
}

//分隔字符串
void spliteString()
{
  argc = 0;
  argv[argc++] = strtok(command, SEP);
  while(argv[argc++] = strtok(NULL, SEP));
#ifdef DEBUG 
  int j = 0;
  for(;argv[j]; j++)
  {
    printf("[%d]->%s\n", j, argv[j]);
  }
#endif
}

void normalExcute()
{
  pid_t id = fork();
  assert(id != -1);
  if(id == 0)
  {
  	if(redir != NONE)
  	{
  	  int fd = 0;
  	  switch(redir)
  	  {
  	    case INPUT:
  	      fd = open(redirFile, O_RDONLY);
  	      dup2(fd, 0);
  	      break;
  	     case OUTPUT:
  	       fd = open(redirFile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  	       dup2(fd, 1);
  	       break;
  	     case APPEND:
  	       fd = open(redirFile, O_WRONLY | O_CREAT | O_APPEND, 0666);
  	       dup2(fd, 1);
  	       break;
  	  }
  	}
    exitcode = 0;
    execvp(argv[0], argv);
    exit(EXIT_CODE);
  }
  else 
  {
    int status = 0;
    pid_t id = waitpid(id, &status, 0);
    exitcode = WEXITSTATUS(status);
  }
}

int buildExcute()
{
  if(argc == 3 && strcmp(argv[0], "cd") == 0)
  {
    int ret = chdir(argv[1]);
    if(ret != -1) exitcode = 0;
    else exitcode = EXIT_CODE;
    return 1;
  }
  else if(argc == 3 && strcmp(argv[0], "export") == 0)
  {
  	env[envNum] = (char*)malloc(sizeof(argv[1]) + 1);
    strcpy(env[envNum], argv[1]);
    int ret = putenv(env[envNum++]);
    if(ret == 0) exitcode = 0;
    else exitcode = EXIT_CODE;
    return 1;
  }
  else if(argc == 3 && strcmp(argv[0], "echo") == 0)
  {
    if(strcmp(argv[1], "$?") == 0) printf("%d\n", exitcode);
    else printf("%s\n", argv[1]);
    return 1;
  }
  else if(strcmp(argv[0], "ls") == 0)
  {
    argv[argc - 1] = (char*)"--color=auto";
    argv[argc] = NULL;
  }
  return 0;
}

int main()
{
  while(1)
  {
    getCommand();
    spliteString();
    int ret = buildExcute();
    if(!ret) normalExcute();
  }
  return 0;
}

★ps：进程历史打开的文件与进行各种重定向关系都和未来的程序替换无关，程序替换不会影响当前进程的文件访问。因为程序替换时，仅对代码及部分数据进行替换，并不会修改当前进程的file*文件描述符表指针。

如何理解Linux系统上一切皆文件

整个计算机中包含着大量的外设，操作系统想要管理好这些外设，就需要对这些外设进行描述，抽象出它们的读写方法（如果没有读方法则存NULL，没有写方法也存NULL）等。从而，对外设的管理变成了对结构体的管理。

不同外设的接口抽象出的结构体可能存在差异，操作系统通过再一层封装，将不同外设抽象成相同的存储结构，便于上层调用。

若某个进程需要访问外设时，则创建一个struct file，该struct file中存储对应的operation_func，当该进程需要操作该外设时，则只需要访问存储该外设operation_func的struct file并找到它的对应方法，即可对外设做操作。

对于上层的保存着operation_func的struct file的集合，我们将其称之为虚拟文件系统。该文件系统存储格式是文件，上层用户看来，Linux中外设也是文件。

🎈欢迎进入从浅学到熟知Linux专栏，查看更多文章。
如果上述内容有任何问题，欢迎在下方留言区指正b(￣▽￣)d