linux系统编程 文件io

1. 文件io讲些什么

文件io这一章讲的是，如何调用Linux OS所提供的相关的OS API，实现文件的读写。

1.1如何理解“文件IO”这个词

IO就是input output的意思，文件io就是文件输入输出，也就是文件读写。
	
读写的是什么？
答：是数据。
	
不过读文件和写文件，到底哪一个是input，哪一个是output呢？
答：input和output，其实是以CPU作为参考点来看的：
                  
                 		o（写）  
				C     ——————————>	 文
				P	 <——————————  	 件
				U		i（读）
					
疑问：为什么不能越过OS，直接操作文件呢？
答：当有OS的时候，应用程序基于OS运行时，必须通过OS API假借OS之手，才能操作底层硬件，无法回避。

1.2 本章所涉及的OS API（系统函数）有哪些

（1）open函数：打开文件

（2）close函数：关闭文件

（3）read函数：从打开的文件读数据

（4）write函数：向打开的文件写数据

（5）lseek函数：移动在文件中要读写的位置

（7）dup函数：文件读写位置重定位函数，本来是写到这个文件，重定位后可以写到另一个文件里面

（11）fcntl函数：文件描述符设置函数

（12）ioctl函数：一个特殊的函数

注意：
本章的函数，在后续课程中会频繁使用，所以这些函数一定要会用，但是不要去死记，函数参数很多，想记也记不住，涉及细节时，使用man查一查自然就知道了。

2. 文件的读写的简单例子

2.1文件读写三步曲

• 打开文件
  open函数
• 读、写等操作文件
  read、write函数
• 关闭文件
  close函数
• 程序演示

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


int main(void)
{
	int fd = 0;

	fd = open("./file.txt", O_RDWR);
	if(-1 == fd)
	{
		printf("open fail\n");
		return 0;
	}
	else
	{
		printf("open ok\n");
	}

	
	char buf1[] = "hello world";
	write(fd, (void *)buf1, 11);

	lseek(fd, 0, SEEK_SET);

	char buf2[30] = {0};
	read(fd, buf2, sizeof(buf2));
	

	printf("buf2 = %s\n", buf2);	
	
	
	close(fd);
	
	return 0;
}

程序解释：
1）open函数			
	（a）利用文件名，通过文件系统找到块设备上的文件
	图：

		· 文件系统就是一个程序代码，组织管理着块设备上的所有文件
		· 文件系统属于OS的一部分
			
			
	（b）找到文件后，调用块设备驱动程序，打开文件
			驱动程序也是属于OS的一部分。
	
			· 打开成功：返回一个非负整数的操作符（文件描述符）
			· 打开失败：返回-1，表示打开失败
	
				使用fd存放返回值，便于我们使用这个返回值。文件打开成功后就可以操作文件了。
				
2）write函数
	利用打开成功后返回的，非负整数的文件描述符，向文件里面写数据。
	
3）lseek函数
	利用文件描述符，将文件读写的位置调整到文件头上。
	
	为什么要调到文件头上？
	write时，文件读写的位置到了末尾了，read读末尾的话，读到的内容就是空的，看不到read的效果。
	
4）read函数
	从文件头上开始，读取指定长度的数据到buf中。
	printf打印显示，查看效果。

2.2 open打开文件时，open具体做了哪些事情

如果open打开失败的话（比如文件不存在就会导致失败），open啥也不会干就直接返回了。
但是如果open将文件打开成功的话，open具体做了哪些事情呢？
	1）记录打开文件的信息
		程序运行起来后就是一个进程了，OS会创建一个task_struct的结构体，记录进程运行时的各种信
	息，比如所打开文件的相关信息；open将文件成功打开后，在task_struct中又会创建一些结构体（数
	据结构），用于记录当前进程目前所开文件的信息，后续所有的文件操作，都需要依赖于这些信息，其中
	就包括指向打开文件的文件描述符。
					图：

	2）open函数会申请一段内存空间（内核缓存），后续读写文件时，用于临时缓存读写文件时的数据
					图：

		（a）什么是缓存？
			就是开辟的一段内存空间，比如char buf[100]，这就是一段100字节的缓存空间，用于临时
		存放中转的数据。
				
		（b）为什么叫内核缓存？
			open是OS所提供的系统函数，属于OS内核的一部分，所以open函数所开辟的缓存空间，就是
		内核缓存。
			
			在我们的例子程序中，我定义了buf1和buf2这两个数组，这两个数组是我自己的应用程序定义
		的，因此就叫应用缓存。
				
			其实定义的一切变量空间，比如int a，int b[30]等，都是缓存，都是用于临时缓存数据，
		只是我们以前没有这么叫过。
				
		（c）open为什么要开内核缓存空间？
			内存读写速度 > 磁盘读写速度的，有了在内存中开辟的内核缓存后，上层读写数据时，
		会直接读写缓存，速度会很快，至于缓存与磁盘上文件数据的交换，就留给下层去做，这样可
		以节省上层操作的时间。

		（d）注意：open时只是开辟了内核缓存空间，里面并没有数据，只有当进行读写数据时，才会缓存
		读写的数据。
		
		（e）读写时，缓存间数据的流动是怎样的？
			写数据：应用缓存 -->内核缓存 -->驱动缓存-->硬件（块设备）
			读数据：硬件（块设备）-->驱动缓存 -->内核缓存 -->应用缓存

3. open函数

3.1 函数原型

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

int open(const char *pathname, int flags);
功能：只能打开存在的文件，如果文件不存在就返回-1报错。
	 
int open(const char *pathname, int flags, mode_t mode);
功能：如果文件存在就直接打开，如果文件不存在，就按照mode指定的文件权限，创建一个该名字的新文件。
		
也就是说三个参数时，不仅包含打开已存在文件的功能，还多了一个创建文件的功能。

3.2 open函数返回值

如果打开成功，返回一个非负整数的文件描述符。
			
如果打开失败，返回-1，并且设置错误号给系统定义的全局变量errno，用于标记函数到底出了什么错误。

有关errno和错误号，后面会详细介绍。

3.3 open函数的重点：flags参数

参数1：pathname，表示路径名，很简单
参数3：mode，创建文件时，用于指定文件的原始权限，其实就是rwxrwxr--。

3.3.1 flags 之 O_RDONLY、O_WRONLY、O_RDWR、O_TRUNC、O_APPEND

• flags的作用
  flags用于指定文件的打开方式，这些宏还可以使用|组合，比如O_RDONLY | O_APPEND，同时指定多个宏。
  不要被这些宏吓到了，理解了，用多了，自然就熟悉了，不用可以去记住，想不起来了，使用man查看open函数就能知道。
  这些宏对应的就是一些整形数，#define O_RDONLY 2。

• 这些宏被定义在了那里？
  定义在了open所需要的头文件中，使用open函数时，必须要包含对应的头文件，否者，这些宏你就用不了。
  （1）宏的含义

   （a）O_RDONLY：只读方式打开文件，只能对文件进行读     
   	
   （b）O_WRONLY：只写方式打开文件，只能对文件记性写
  
   （c）O_RDWR：可读可写方式打开文件，既能读文件，也能写文件
  
   	以上这三个在指定时，只能唯一指定，不可以组合，比如O_RDONLY|O_WRONLY。
  
   （d）O_TRUNC：打开时将文件内容全部清零空
   
   （e）O_APPEND：打开文件后，写数据时，原有数据保留，新写的数据追加到文件末尾，此选项很重要。
   	APPEND本来就是追加的意思。
   	如果不指定这个选项的话，新写入的数据会从文件头上开始写，覆盖原有的数据，所有以后
   	会经常使用这个选项。
   
   （f）O_NONBLOCK和O_ASYNC：后面的课程用到后，再来介绍。
  

  (2) 代码演示

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

int main(void)
{
	int fd = 0;
	int ret = 0;

	fd = open("./file.txt", O_RDWR);
	//fd = open("./file.txt", O_RDWR|O_APPEND);
	//fd = open("./file.txt", O_RDWR|O_TRUNC);
	//fd = open("./file.txt", O_RDONLY);
	//fd = open("./file.txt", O_WRONLY);
	if(-1 == fd)
	{
		printf("open fail\n");
		return 0;
	}
	else
	{
		printf("open ok\n");
	}

	
	char buf1[] = "hello world";
	ret = write(fd, (void *)buf1, 11);
	if(ret == -1)
	{
		printf("write fail\n");
	}


	lseek(fd, 0, SEEK_SET);

	char buf2[30] = {0};
	ret = read(fd, buf2, sizeof(buf2));
	if(-1 == ret)
	{
		printf("read fail\n");
	}

	printf("buf2 = %s\n", buf2);	
	
	
	close(fd);
	
	return 0;
}

3.3.2 flags参数 之 O_CREAT、O_EXCL

（1）O_CREAT
	1）open两个参数时的缺点
		只能用于打开已经存在的文件，如果文件不存在就返回-1报错。

	2）O_CREAT的作用
		可以解决两个参数的缺点，指定O_CREAT时，如果：
		（a）文件存在：直接打开
		（b）文件不存在：创建该“名字”的文件。
		
			不过指定O_CREAT，需要给open指定第三个参数mode，用于指定新创建文件的原始权限。
			int open(const char *pathname, int flags, mode_t mode);
		
		这个权限就是文件属性中的rwxrwxr--。
					
					
（2）O_EXCL
		当O_EXCL与O_CREAT同时被指定，打开文件时，如果文件之前就存在的话，就报错。
		
		意义：保证每次open的是一个新的文件，如果文件以前就存在，提醒你open的不是一个新文件。
		
		后面具体用到了，你自然就知道O_EXCL的实用价值了。

3.4 详论文件描述符

3.4.1 什么是文件描述符

	open成功就会返回一个非负整数（0、1、2、3...）的文件描述符，比如我们示例程序中open返回的文
件描述符是3。
	文件描述符指向了打开的文件，后续的read/write/close等函数的文件操作，都是通过文件描述符来实
现的。

3.4.2 文件描述符池

	每个程序运行起来后，就是一个进程，系统会给每个进程分配0~1023的文件描述符范围，也就是说每个进
程打开文件时，open所返回的文件描述符，是在0~1023范围中的某个数字。0~1023这个范围，其实就是文件
描述符池。
	1023这个上限可不可以改？
	可以，但是没有必要，也不会介绍如何去改，因为一个进程基本不可能出现，同时打开1023个文件的情况
，文件描述符的数量百分百够用。

3.4.3 在我们的例子中，为什么open返回的是3

open返回文件描述符是有规则的：
	规则就是，open返回文件描述符池中，当前最小没用的哪一个。
	进程一运行起来，0/1/2默认就被使用了，最小没被用的是3，所以返回3。
	如果又打开一个文件，最小没被用的就应该是4，所以open返回的应该是4。
	疑问：0、1、2被用来干嘛了，后面解释。

3.4.4 文件关闭后，被文件用的描述符怎么办

会被释放，等着下一次open时，被重复利用。

3.4.5 open的文件描述符 与 fopen的文件指针

（1）open：Linux 的系统函数（文件io函数）
	open成功后，返回的文件描述符，指向了打开的文件。
					
（2）fopen：C库的标准io函数
	#include <stdio.h>				
	FILE *fopen(const char *path, const char *mode);
	fopen成功后，返回的是FILE *的文件指针，指向了打开的文件。
				
（3）对于Linux的C库来说，fopen 这个C库函数，最终其实还是open函数来打开文件的
	fopen只是对open这个函数做了二次封装。

							      应用程序
												|
												|
							FILE*	fopen标准io函数（c库函数）
												|
												|
							int	open文件io函数（Linux系统函数）
			
   也就是说，fopen的文件指针，最终还是会被换成open的文件描述符，然后用于去操作打开的文件。
讲第3章-C库的标准io函数时，会详细介绍文件指针与文件描述符之间的关系。

3.5 errno和错误号

	在我们的例子中，如果open失败了，只是笼统的打印出“打开文件失败了”，但是并没有提示具体出错的原
因，没有详细的出错原因提示，遇到比较难排查的错误原因时，很难排查出具体的函数错误。			
	open失败，如何具体打印出详细的出错信息呢？
	这就不得不提errno的作用了。

（1）什么是ernno？
	函数调用出错时，Linux系统使用错误编号（整形数）来标记具体出错的原因，每个函数有很多错误号，
每个错误号代表了一种错误，产生这个错误时，会自动的将错误号赋值给errno这个全局变量。
	errno是Linux系统定义的全局变量，可以直接使用。
	错误号和errno全局变量被定义在了哪里？
		都被定义在了errno.h头文件，使用errno时需要包含这个头文件。
		man errno，就可以查到errno.h头文件。
						
（2）打印出具体的出错原因
	1）printf打印出错误号
		使用errno时，编译提示‘errno’ undeclare的错误，表示找不到errno全局变量。
		错误号确实标记了具体的出错原因，但是我们并不知道这个错误号，具体到底代表的是什么错误。
	就好像光给你某人的身份证号，仅凭这个身份证号你无法判断是那一个人，需要换成名字才成。
							
	2）perror函数
		perror函数可以自动将“错误号”换成对应的文字信息，并打印出来，方便我们理解。
		man perror
		perror是一个C库函数，不是一个系统函数。
		perror的工作原理？
		调用perror函数时，它会自动去一张对照表，将errno中保存的错误号，换成具体的文字信息并打
	印出来，我们就能知道函数的具体错误原因了。
		
	3）man 2 open，可以查看open函数，都有哪些错误号
		每个错误号代表了一种函数可能的出错情况，比如：
		EACCES：不允许你访问文件而出错。
		Liunx为了让错误号能够见名识意，都给这些整形的错误号定义了对应的宏名，这些宏定义都被定义
	在了error.h头文件中。man perror这个函数，也可以看到这个头文件。
		疑问：我是不是要必须记住这些错误号？
			答：反正我是记不住，记不住怎么办？
			根本不需要记住，使用perror函数，它可以自动翻译，我们讲错误号，只是希望你理解错误号
		这个东西，后面的课程会经常见到东西，到了后面我就不再介绍。

使用演示：

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


int main(void)
{
	int fd = 0;


	fd = open("./file.txt", O_RDWR);
	//fd = open("./file.txt", O_RDWR|O_CREAT|O_EXCL, 0664);
	if(-1 == fd)
	{
		printf("open fail: %d\n", errno);
		perror("open fail");
		return 0;
	}
	else
	{
		printf("open ok\n");
		printf("fd = %d\n", fd);
	}

	
	char buf1[] = "hello world";
	write(fd, (void *)buf1, 11);

	lseek(fd, SEEK_SET, 0);

	char buf2[30] = {0};
	read(fd, buf2, sizeof(buf2));
	

	printf("buf2 = %s\n", buf2);	
	close(fd);

	return 0;
}

4. close、write、read、0/1/2这三个文件描述符

4.1 close函数

4.1.1 功能

关闭打开的文件。
close(fd);
就算不主动的调用close函数关闭打开的文件，进程结束时，也会自动关闭进程所打开的所有的文件。
但是如果因为某种需求，你需要在进程结束之前关闭文件的话，就主动的调用close函数来实现。
Linux c库的标准io函数fclose，向下调用时，调用就是close系统函数。

4.1.2 close关闭文件时做了什么

（1）open打开文件时，会在进程的task_struct结构中，创建相应的结构体，以存放打开文件的相关信息。
		
（2）结构体的空间开辟于哪里
	open函数会通过调用类似malloc的函数，在内存中开辟相应的结构体空间，如果文件被关闭，存放该文
件被打开时信息的结构体空间，就必须被释放，类似free(空间地址);不过malloc和free是给C应用程序调
用的库函数，Linux系统内部开辟和释放空间时，用的是自己特有的函数。如果不释放，当前进程的内存空间
，会被一堆的站着茅坑不拉屎的垃圾信息所占用，随后会导致进程崩溃，甚至是Linux系统的崩溃。这就好比
一个挺大的仓库，每次废弃的物品都不及时清理，最后整个空间全被垃圾塞满，仓库还是那个仓库，但是仓
库瘫痪了，无法被正常使用。因此close文件时，会做一件非常重要的事情，释放存放文件打开信息的结构体
空间。

（3）有关task_stuct结构体
	1）这个结构体用于存放进程在运行的过程中，所涉及到的各种信息，其中就包括进程所打开文件的相关
信息。
	2）task_stuct结构体，什么时候开辟的？
		进程（程序）开始运行时，由Linux系统调用自己的系统函数，在内存中开辟的，
		代码定义个各种变量（int a、数组、结构体、对象等），开辟这些空间时，这些空间都是来自于
	内存。
		每一个进程都有一个自己的task_stuct结构体，用于记录自己的所有相关信息，这就好比每一个人
	，在公安局都有一份属于自己的档案信息，task_stuct结构体记录的就是，进程在活着时的一切档案
	信息。
	3）什么时候释放
		进程运行结束了，Linux系统会调用自己的系统函数，释放这个结构体空间，如果不释放的话，每运
	行一个进程就开辟一个，但是进程结束后都不释放，最后会导致Linux系统自己的内存空间不足，从而
	使得整个Linux系统崩溃。

4.2 write函数

函数原型：

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
（1）功能：向fd所指向的文件写入数据。
（2）参数
		1）fd：指向打开的文件
		2）buf：保存数据的缓存空间的起始地址
		3）count：从起地址开始算起，把缓存中count个字符，写入fd指向的文件
		
数据中转的过程：
应用缓存（buf）————>open打开文件时开辟的内核缓存——————>驱动程序的缓存——————>块设备上的文件
（3）返回值
		调用成功：返回所写的字符个数
		调用失败：返回-1，并给errno自动设置错误号，使用perror这样的函数，就可以自动的将errno
	中的错误号翻译为文字。

4.3 read函数

函数原型：

#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
（1）功能：从fd指向的文件中，将数据读到应用缓存buf中
（2）参数
	1）fd：指向打开的文件
	2）buf：读取到数据后，用于存放数据的应用缓存的起始地址
	3）count：缓存大小（字节数）
（3）返回值
	1）成功：返回读取到的字符的个数
	2）失败：返回-1，并自动将错误号设置给errno。
	
数据中转的过程：
应用缓存（buf）<————open打开文件时开辟的内核缓存<——————驱动程序的缓存<——————块设备上的文件

4.4 0/1/2这三个文件描述符

（1）程序开始运行时，有三个文件被自动打开了，打开时分别使用了这三个文件描述符。
（2）依次打开的三个文件分别是
	/dev/stdin，/dev/stdout，/dev/stderr。
	1）/dev/stdin：标准输入文件
	（a）程序开始运行时，默认会调用open("/dev/stdin", O_RDONLY)将其打开，返回的文件描述符
	是0
	（b）使用0这个文件描述符，可以从键盘输入的数据
			简单理解就是，/dev/stdin这个文件代表了键盘。
	（c）思考：read(0, buf, sizeof(buf))实现的是什么功能
			实现的是，从键盘读取数据到到缓存buf中，数据中转的过程是：
		read应用缓存buf <—————— open /dev/stdin时开辟的内核缓存 <——————键盘驱动程序
		的缓存 <——————键盘
				
		疑问：能够像读普通文件一样读键盘吗？
			答：在Linux下，应用程序通过OS API操作底层硬件时，都是以文件形式来操作的，不管是
		读键盘，还是向显示器输出文字显示，都是以文件形式来读写的，在Linux下有句很经典的话，
		叫做“在Linux下一切皆文件”，说的就是这么个意思。
	（d）思考：为什么在我们的程序中，默认就能使用scanf函数从键盘输入数据
			我们默认就打开了代表了键盘/dev/stdin，打开后0指向这个打开的文件。
			scanf下层调用的就是read，read自动使用0来读数据，自然就可以从键盘读到数据。
							
							scanf("%s", sbuf) C库函数
									|
									|
							read(0, rbuf, ***)
			我们从键盘读取数据时，可以直接调用read这个系统函数来实现，也可以调用scanf C库函
			数来实现，只不过在一般情况下，我们在实际编写应用程序时，调用的更多的还是scanf 这
			个c库函数，原因如下：
				· 调用库函数，可以让程序能够更好的兼容不同OS，能够在不同的OS运行
				· scanf在read基础上，加入更加人性化的、更加便捷的功能，比如格式化转换
			
			直接使用read的缺点
				首先我们必须清楚，所有从键盘输入的都是字符，从键盘输入100，其实输入的是三个字
			符'1'、'0'、'0'，因此使用read函数从键盘读数据时，读到的永远都是字符。
			 但是如果你实际想得到的是整形数的100，你就必须自己将'1'、'0'、'0'转为整形的100

			每次使用read获取一个整形数时，你都要自己转换，如果你要输入的是浮点数的话，转起来更
		麻烦。
			
			- scanf的优点
			scanf可以解决read的缺点，虽然scanf调用read时，从键盘读到的全部都是字符，但是你
		只要给scanf指定%d、%f等格式，scanf会自动的讲read读到的字符串形式的数据，转为整形或
		者浮点型数据。
										
										scanf("%d", &a);
													|
													|
											read(0, buf, ...);
		如果直接调用read读取，然后自己再来转换，相当于自己再实现scanf函数的基本功能。
		疑问：有了scanf函数后，read系统函数是不是没有调用的意义了，当然不是的，在有些时候，
	特别是讲到后面驱动时，有些情况还就只能使用read，不能使用scanf，学到后面就知道了。
		（e）思考：close(0)后，scanf还能工作吗？
								为什么不能工作？
									scanf("%s", sbuf) C库函数
												|
												|
									read(0, rbuf, ***)
	
	2）/dev/stdout：标准输出文件
	（a）程序开始运行时，默认open("/dev/stdout", O_WRONLY)将其打开，返回的文件描述符是1		
		为什么返回的是1，先打开的是/dev/stdin，把最小的0用了，剩下最小没用的是1，因此返回的
	肯定是1。
	（b）通过1这个文件描述符，可以将数据写（打印）到屏幕上显示
		简单理解就是，/dev/stdout这个文件代表了显示器。
	（c）思考：write(1, buf, strlen(buf))实现的是什么功能
		将buf中的数据写到屏幕上显示，数据中转的过程是：
		write应用缓存buf ——————> open /dev/stdout时开辟的内核缓存 ——————> 显示器驱动程
	序的缓存 ——————> 显示器
	（d）思考：为什么在我们的程序中，默认就能使用printf打印数据到显示器
		因为程序开始运行时，就默认打开了代表了显示器/dev/stdout文件，然后1指向这个打开的文件。
		printf下层调用的是write函数，write会使用1来写数据，既然1所指文件代表的是显示器，自然
	就可以将数据写到显示器了。
										printf("*****")
											|
											|
										write(1, buf, count);
	（e）思考：如何使用write函数，将整数65输出到屏幕显示？
			直接输出行不行
			int a = 65；
			write(1, &a, sizeof(a));
			为什么输出结果是A？
				人只看得懂字符，所以所有输出到屏幕显示的，都必须转成字符。
			所以我们输出时，输出的必须是文字编码，显示时会自动将文字编码翻译为字符
			图形。
			所以我们输出65时，65解读为A字符的ASCII编码，编码被翻译后的图形自然就是A。
			
			怎么才能打印出65
				如果要输出65，就必须将整形65转为'6'和'5'，输出这两个字符才行。
			输出'6'、'5'时，其实输出的是'6'、'5'这两个字符的ASCII编码，然后会被自动的
			翻译为6和5这两个图形。总之将整形65，转为字符'6'、'5'输出即可。
				
			为什么printf会对wirte进行封装
				- 库函数可以很好的兼容不同的OS
				- 封装时，叠加了很多的功能，比如格式化转换
				通过指定%d、%f等，自动将其换为对应的字符，然后write输出，完全不用自
			己来转换。
									
			思考：printf使用%s、%c输出字符串和字符时，还用转吗？
				其实不用转，因为要输出的本来就是字符，printf直接把字符给write就行了，当
			然也不是一点事情也不做，还是会做点小处理的。
		
		（f）思考：close(1)，printf函数还能正常工作吗？
				结果是不能
						
									printf("*****")
												|
												|
									write(1, buf, count);
					
	3）/dev/stderr：标准出错输出文件
	（a）默认open("/dev/stderr", O_WRONLY)将其打开，返回的文件描述符是2	
	（b）通过2这个文件描述符，可以将报错信息写（打印）到屏幕上显示
	（c）思考：write(2, buf, sizeof(buf))实现的是什么功能
		将buf中的数据写道屏幕上，数据中转的过程是：
		write应用缓存buf ——————> open /dev/stderr时开辟的内核缓存 ——————> 显示器驱
	动程序的缓存 ——————> 显示器
	（d）疑问：1和2啥区别？
		使用这两个文件描述符，都能够把文字信息打印到屏幕。
		如果仅仅是站在打印显示的角度，其实用哪一个文件描述符都能办到。
		1、2：有各自的用途
			- 1：专用于打印普通信息
			- 2：专门用于打印各种报错信息
			- 使用write输出时
				+ 如果你输出的是普通信息，就使用1输出。
				+ 如果你输出的是报错信息，就使用2输出
								
		 printf和perror调用write时，使用的是什么描述符
			- printf
				printf用于输出普通信息，向下调用write时，使用的是1。
				前面已经验证过，close(1)后，printf无法正常输出。
			- perror
				perror专门用于输出报错信息的，因为输出的是报错信息，因此write使用的是2。
				验证：将2关闭，perror就会无法正常输出。
		
		后面讲到标准io时，还会讲到标准输入、标准输出、标准出错输出，到时候会介绍标准输出、标准
	出错输出的区别。
								
4）STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO
	系统为了方便使用0/1/2，系统分别对应的给了三个宏
		0：STDIN_FILENO
		1：STDOUT_FILENO
		2：STDERR_FILENO
									
		可以使用三个宏，来代替使用0/1/2。
		这三个宏定义在了open或者read、write函数所需要的头文件中，只要你包含了open或者read
	、write的头文件，这三个宏就能被正常使用。

5. lseek函数

函数原型和头文件：

#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);

功能：

	调整读写的位置，就像在纸上写字时，挪动笔尖所指位置是一样的。
	C库的标准io函数里面有一个fseek函数，也是用于调整读写位置的，fseek就是对lseek系统函数封装后
实现的，后面讲到标准io时，还会讲到fseek函数。

返回值：

调用成功
	返回当前读写位置相对于文件开始位置的偏移量（字节）。
				
可以使用lseek函数获取文件的大小，怎么获取？
	答：将文件读写的位置移动到最末尾，然后获取返回值，这个返回值就是文件头与文件尾之间的字节数
，也就是文件大小。
				
调用失败
	返回-1，并给errno设置错误号。

参数：

off_t lseek(int fd, off_t offset, int whence);

1）fd：文件描述符，指向打开的文件

2）whence：
	粗定位，选项有：
	SEEK_SET：调到文件起始位置
	
	SEEK_CUR：调到文件当前读写的位置
	
	SEEK_END：调到文件末尾位置

3）offset
	精定位：微调位置
	
	从whence指定的位置，向前或者向后移动指定字节数。
	
	为负数：向前移动指定字节数
	为正数：向后移动指定字节数
			
	不过当whence被指定为SEEK_SET时，如果offset被指定为负数的话，是没有意义，为什么？
		因为已经到文件头上了，在向前移动就越界了，不再当前文件的范围内了，如果非要向前调整，
	lseek函数会报错。

od -c 文件：以字符形式查看文件内容。
可以使用lseek制作出空洞文件，留到下一章再来介绍。

6. 文件描述符表

6.1 什么是文件描述符表

	在前面的课程中，我们说当open打开文件成功后，会创建相应的结构体（数据结构），用于保存被打开文
件的相关信息，对文件进行读写等操作时，会用到这些信息，这个数据结构就是我们要讲的“文件描述符表”。

6.2 进程表：task_struct

	前面我们介绍过task_struct结构体，这个结构体又叫进程表。这个结构体的成员项非常多，多达近300
个。每一个进程运行起来后，Linux系统都会为其在内存中开辟一个task_struct结构体，task_struct专门
用于存放进程在运行过程中，所涉及到的所有与进程相关的信息其中，文件描述符表就被包含在了
task_struct中。进程运行结束后，进程表所占用的内存空间，会被释放。

6.3 task_struct 与 文件描述符表 之间的关系

6.3.1 关系图

0/1/2默认被使用了。
文件状态标志：
1）是什么

	就是open文件时指定的O_RDONLY、O_WRONLY、O_RDWR、O_TRUNC、O_APPEND、O_CREAT、
O_EXCL、O_NONBLOCK、O_ASYNC等文件状态标志。
	比如：fd = open("./file1.txt", O_RDWR|O_CREAT|O_EXCL, 0664);
	open打开文件成功后，会将文件状态标志保存到“文件表”中。

2）有什么用

	读写文件时，会先检查“文件状态标志”，看看有没有操作权限，然后再去操作文件。
	比如open时指定的是：
	（a）O_RDONLY
		写（wrtie）文件时，通过fd检查“文件状态标志位”，发现只允许读，写操作会错误返回，并报
	“不允许写的错误”。
	（b）O_WRONLY
		读（read）文件时，通过fd检查“文件状态标志位”，发现只允许写，读操作会错误返回，并报
	“不允许读的错误”。
	只有当“文件状态标志”允许相应的操作时，读写操作才能成功进行。

文件位移量 与 文件长度：

	它们不是一回事，不要搞混。
	1）文件位移量：文件当前读写位置与文件开始位置的距离（字节数）。
		“文件位移量”代表的就是文件读写的位置，read、write读写数据时，通过文件位移量，就知道从
	哪里开始读写了。
		一般情况下打开文件时，文件的位移量默认为0，表示读写的位置在文件头上。每读写一个字节，
	文件读写位置（笔尖）就往后移动一个字节，文件位移量随之+1。调用lseek函数调整文件读写位
	置，其实就是修改文件位移量。
	2）文件长度：文件的大小
		在写文件的过程中，每写一个字节的数据到文件中，文件的长度就+1，文件长度也是动态更新的。
（3）函数指针
		read、write等操作文件时，会根据底层具体情况的不同，调用不同的函数来实现读写，所以在V
	节点里面保存了这些不同函数的函数指针，方便调用。

6.3.2 O_APPEND

（1）功能
	open文件时，如果指定了这个文件状态标志，表示以追加的方式打开文件。
	写文件时，会从文件的最末尾开始写操作。
（2）追加的实现原理
	文件的位移量代表的，就是文件的读写位置。
	open指定了O_APPEND时，每次写文件时，都会把“文件位移量”设置为“文件的长度”，也就是说写的位
置被调整到了末尾，写文件时从文件尾部进行追加。每一次写操作后，文件的内容会增加，那么自然文件的长
度会被动态更新。总之，指定了O_APPEND后，每次写文件时，都会使用文件长度去更新文件位移量，保证每
次都是从最末尾开始写数据的。
（3）O_APPEND的意义
	多次open同一文件，实现共享操作时，指定O_APPEND可以防止数据相互覆盖的发生，后面会详细介绍。

6.3.3 O_TRUNC

	如果文件中原来就有数据的话，open打开文件时，会全部被清空。由于文件已经被清空了，所以将V节点
中的文件长度，修改为0。

6.4 共享操作文件

介绍两种情况：
· 同一进程共享操作相同的文件
· 多个进程之间，共享操作相同文件

6.4.1 同一进程（程序），多次open同一个文件

在同一个进程中多次open打开同一文件时，文件描述符可能会相同吗？

	答：不可能。在同一进程里面，一旦某个文件描述符被用了，在close释放之前，别人不可能使用，所以指向同
一文件的描述符不可能相同。

例子中写数据时，为什么会相互的覆盖？
1）看看共享操作时的文件描述符表长啥样
图：

	由图知道，正是由于不同的文件描述符，各自对应一个独立的文件表，在文件表中有属于自己的“文件位移
量”	，开始时都是0。各自从0开始写，每写一个字节向后移动一个字节，他们写的位置是重叠的，因此肯定会
相互的覆盖。

2）怎么解决

（a）指定O_APPEND即可解决
	必须每个open都要指定，有一个不指定就会覆盖，就先过马路一样，都要准守交通规则才能安全，开车的
和行人，只要有一个不准守都会出事。
（b）为什么使用O_APPEND可以解决
	文件长度信息时大家共享的，当文件被写入数据后，文件长度就会被更新，都指定O_APPEND后，使用不
同的文件描述符写数据时，都会使用文件长度更新自己的文件位移量，保证每次都是在文件的最末尾写数据，
就不会出现相互覆盖的情况。

6.4.2 多个进程（程序），共享操作同一个文件

	不同进程打开同一文件时，各自使用的文件描述符值可能相等，比如我们例子中的1和2进程，它们open后
的描述符就相等。之所以相同，是因为不同的进程有自己独立的文件描述符池，都是0~1023的范围，各自分
配自己的，有可能分派到相等值的文件描述符。

1）看看进程表和文件描述符表
图：

同样也是因为各自有独立的文件位移量造成覆盖的问题。

2）解决办法：

	同样的，指定O_APPEND标志，写操作时，使用文件长度去更新文件位移量，保证各自操作时，都在文件的尾
部操作，就不会出现相互覆盖的情况。

7. dup和dup2函数

7.1 dup函数

7.1.1 函数原型

#include <unistd.h>
int dup(int oldfd);
（1）功能
		复制某个已经打开的文件描述符，得到一个新的描述符，这个新的描述符，也指向被复制描述符所指
	向的文件。
		比如：4指向了某个文件，从4复制出5，让5也指向4指向的文件。
				
						4 ——————> 		file.txt
															   ^
					 dup									   |
															   |	
						5 ——————————|
		至于需要用到的新描述符，dup会使用描述符池（0~1023）中当前最小没用的那一个。
（2）返回值
		1）成功：返回复制后的新文件描述符
		
		2）失败：返回-1，并且errno被设置。
				
（3）参数
		oldfd：会被复制的、已经存在的文件描述符。

7.2 dup2函数

7.2.1 函数原型

#include <unistd.h>
int dup2(int oldfd, int newfd);
		
（1）功能
	功能同dup，只不过在dup2里面，我们可以自己指定新文件描述符。
	如果这个新文件描述符已经被打开了，dup2会把它给关闭后，再使用。
	比如：
	dup(2, 3);
	从2复制出3，让3也指向2所指向的文件，如果3之前被打开过了，dup2会关闭它，然后在使用。
	
	dup2和dup的不同之处在于：
	dup：自己到文件描述符池中找新文件描述符
	dup2：我们可以自己指定新文件描述符

				
（2）返回值
		1）成功：返回复制后的新文件描述符

		2）失败：返回-1，并且errno被设置。
			
			
（3）参数
		oldfd：会被复制的、已经存在的文件描述符。
		newfd：新的文件描述符

7.3 dup、dup2复制的意义

7.3.1 实现文件共享操作

复制后文件描述符表：
图：

1）为什么没有出现相互覆盖情况？

	使用dup、dup2复制方式实现文件共享时，不管复制出多少个文件描述符，它们永远只有一个文件表，所
以使用所有描述符去操作文件时，最后使用的都是通过同一个文件位移量，不管谁操作后文件位移量都会被更
新，因此不会出现覆盖。

7.3.2 实现重定位

（1）什么是重定位？

	某文件描述符原来指向了A文件，输出数据是输出到A文件，但是重定位后，文件描述符指向了B文件，输
出时数	据输出到了B文件，这就是重定位。
	所谓重定位，说白了就是，文件描述符所指向的文件该变了，使得数据输出的目标文件也随之变。

（2） 举例使用dup、dup2实现重定位

回顾printf与write的关系
						printf(...)
							|
							|
						write(1, buf, ...)
	printf输出时，原本通过1，将数据输出到标准输出文件（显示器）的，但是现在，我想让printf输出
到file.txt文件，而不是输出到屏幕，应该怎么办？
	最简单的办法是就是，把printf函数调用的write函数里面的1，改成指向file.txt文件的新描述符即
可，但是不幸的是write中的1写死了，1这个数字改不了，怎么办？
	1这个数改不了，但是可以对1进行重定位，让1不再指向标准输出文件，而是指向file.txt，printf的
数据，就输出到了file.txt文件中。

	实现步骤
	（a）open file.txt文件，返回一个文件描述符，比如3
						3 ————> file.txt
	（b）close(1)，不要再让1指向标准输出文件（/dev/stdout）
	（c） 使用dup、dup2把3复制到1上，让1也指向file.txt文件
				
								3——————>file.txt
													^
													|
								1—————————|  X  ——————> /dev/stdout
		1这个文件描述符就被重定位了，凡是通过1输出的数据，都被写到了file.txt中，printf底层调
	用的是write(1, ...)，用的也是1，printf的数据就被输出到了file.txt中。相当于printf函数
	的输出目的地，被重定位为了新的文件，这就是重定位。

代码演示：

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

#define FILE_NAME "./file.txt"


void print_error(char * str)
{
	perror(str);
	exit(-1);
}


int main(void)
{
	int fd1 = 0;
	int fd2 = 0;
	
	fd1 = open(FILE_NAME, O_RDWR|O_TRUNC);
	if(-1 == fd1) print_error("1 open fail");

	//close(1);
	//fd2 = dup(fd1);
	
	dup2(fd1, 1);
	//printf("fd2 = %d\n", fd2);
	
	printf("hello world\n");	

	return 0;
}

（3） 什么时候会使用dup、dup2，来实现从定位

	函数中的文件描述符值写死了，无法修改为新的描述符，但是你又希望该函数，把数据输出到其它文件中
，此时就可以使用dup、dup2对该函数中的文件描述符，进行重定位，指向新的文件，函数就会将数据输出到
这个新文件。

（4） 重定位 >

	重定位 命令（>）是dup、dup2的典型应用，这个命令在重定位时，就是调用dup、dup2函数来实现的。
	1）>使用的例子
		ls > file.txt
		ls的结果原本是输出到显示器的，但是>从定位后，就输出到了file.txt文件。
	2）具体从定位的过程
	（a）>命令（程序）会open打开file.txt文件，假设返回的文件描述符是3
		3————>file.txt
	（b）ls命令（程序）原本会调用write(1, ...)，将结果输出到标准输出文件（显示器），但是 >会
	调用dup2，把3复制到1上，实现重定位，让1也指向file.txt文件，ls的结果自然就输出到file.txt
	文件了。
			
				3————>file.txt
							^
							|
							|
				1—————|  X  ——————> /dev/stdout

8. 总结：文件的共享操作

（1）回顾单一进程多次open同一个文件，实现共享操作
图：

（2）多个进程多次open，共享操作同一个文件
图：

（3）在单个进程中，使用dup、dup2实现文件共享操作
图：

9. fcntl函数

9.1 函数原型

#include <unistd.h>
#include <fcntl.h>
	
int fcntl(int fd, int cmd, ... /* arg */ );

不要去记我们讲的这些函数，但现在为止我也没记不住。
我能记住的就是他们大概的用法，用到时，直接查阅man手册或者相关资料，自然就能立刻把它用起来。
所以对于大家来说，学习这些函数的重点是于理解，而不是记住。
（1）功能				
	fcntl函数其实是File Control的缩写，通过fcntl可以设置、或者修改已打开的文件性质。
（2）返回值
		调用成功：返回值视具体参数而定，这个后面还会再介绍
		调用失败：返回-1，并把错误号设置给errno。
（3）参数
	int fcntl(int fd, int cmd, ... /* arg */ );
	1）fd：指向打开文件
	2）cmd：控制命令，通过指定不同的宏来修改fd所指向文件的性质。
		（a）F_DUPFD
			复制描述符，可用来用来模拟dup和dup2，后面会有例子对此用法进行说明。
			返回值：返回复制后的新文件描述
		（b）F_GETFL、F_SETFL
			获取、设置文件状态标志，比如在open时没有指定O_APPEND，可以使用fcntl函数来补设。
			返回值：返回文件的状态
			什么时候需要fcntl来补设？
			当文件描述符不是你自己open得到，而是调用别人给的函数，别人的函数去open某个文件，
		然后再将文件描述符返回给你用，在这种情况下，我们是没办法去修改被人的函数，在他调用的
		open函数里补加文件状态标志。此时就可以使用fcntl来布设了，使用fcntl补设时，你只需要知
		道文件描述符即可。
			c、d、e这三种情况，后面课程中具体涉及到后，再来详细介绍如何。
		（c）F_GETFD、F_SETFD	
		（d）F_GETOWN、F_SETOWN
		（e）F_GETLK或F_SETLK或F_SETLKW

9.2 测试用例

9.2.1 fcntl 模拟dup和dup2

	不过，我们真要进行文件描述符复制时，往往都使用dup、dup2来实现，而不会使用fcntl，这里使用
fcntl来模拟dup、dup2，完全是为了向大家演示一下，fcntl这个函数是怎么用的。

fcntl模拟dup2 代码演示：

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


int main(void)
{
	int fd = 0;


	fd = open("./file.txt", O_RDWR);
	if(-1 == fd)
	{
		printf("open fail: %d\n", errno);
		return 0;
	}

	
	/* 模拟dup2 */
	//dup2(fd, 1);
	close(1);
	fcntl(fd, F_DUPFD, 1);
	
	printf("hello world!!\n");	
	
	
	return 0;
}

	dup2进行复制时，如果新的文件描述符已经被用，dup2函数会关闭它，然后再复制，但是fcntl模拟
dup2时，必须自己手动的调用close来关闭，然后再进行复制。

9.2.2 fcntl补设O_APPEND文件状态标志

代码演示：

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

int open_fun1(void)
{
	int fd = open("./file.txt", O_RDWR);
	if(-1 == fd)
	{
		printf("open fail: %d\n", errno);
		return 0;
	}
	return fd;
}	

int open_fun2(void)
{
	int fd = open("./file.txt", O_RDWR);
	if(-1 == fd)
	{
		printf("open fail: %d\n", errno);
		return 0;
	}
	return fd;
}	

int main(void)
{
	int fd1 = 0;
	int fd2 = 0;
	int flag = 0;

	fd1 = open_fun1();
	fd2 = open_fun2();
	
	/* 直接制定F_SETFL时，会直接使用新的标志，去修改掉就的标志
	   返回的是新设置的标志
	 */
	flag = O_WRONLY|O_TRUNC|O_APPEND;
	fcntl(fd1, F_SETFL, flag);

	/* 保留原有标志，然后在原有标志的基础上，叠加新标志 */
	flag = fcntl(fd2, F_GETFL, 0);//获取原有标志
	flag = flag | O_TRUNC | O_APPEND;//叠加
	fcntl(fd2, F_SETFL, flag); //设置回去
	
	while(1)
	{
		write(fd1, "hello\n", 6);
		sleep(1);
		write(fd2, "world\n", 6);
	}
		
	
	return 0;
}

10. ioctl函数

为什么有ioctl这个函数？

	在某些特殊的情况下，使用read、write、lseek函数进行文件io（读写）操作时，存在一定的问题，
此时往往就是使用ioctl函数，来实现这些比较特殊情况的io操作。
	ioctl是一个杂物箱，根据设置参数的不同，有很多种不同的功能，如果没有特定使用环境作为支撑的话
，这个函数理解起来不太容易，因此在这里，我们先记住有这么一个函数，有关它的使用，等后面涉及到
了具体应用环境时，再来具体讲解。