LINUX 笔记5

一、文件&文件系统

PDF上定义：

文件：An object that can be written to, or read from, or both. A file has certain attributes, including access permissions and type.

文件系统：A collection of files and certain of their attributes. It provides a name space for file serial numbers referring to those files.

文件类型和结构：

Linux的文件系统：

VFS（Virtual File system Switch ）

VFS(VirtualFileSystem)称“虚拟文件系统”，是LINUX文件系统的一个重要的组成部分。它不是一个真正的文件系统，实际上它是一种软件机制，也许称它为Linux的文件系统管理者更确切点。

VFS的四个对象：

VFS中有四个主要的对象结构：
     超级块对象(super_block)，代表一个已安装文件系统。

     索引节点对象(inode)，代表一个文件。(文件的相关信息)

     文件对象(file)，代表有进程打开的文件。(文件本身)

     目录项对象(dentry)，代表一个目录项，是路径(path)的组成部分。

每个主要对象都包含一个操作对象，这些操作对象描述了内核针对主要对象可以使用的方法：

     super_operations对象，其中包括内核针对特定文件系统所能调用的方法。

     inode_operations对象，其中包括针对特定文件所能调用的方法。

     file_operations对象，其中包括内核针对已打开的文件所能调用的方法。

     dentry_operations对象，其中包括内核针对特定目录项所能调用的方法。

VFS有什么好处？
支持N多种杂七杂八的文件系统
用惯了WINDOWS的人都知道在格式化文件系统的时候只有少数几种种选择：FAT和NTFS等等。但是LINUX却可以支持诸如EXT2，Minix，FAT，VFAT，NFS，NTFS…等等10多个不同的文件系统。正是VFS，为LINUX实现了这一强大功能。
概括来说，实现这种支持是通过文件系统的“注册”来完成的。经由注册的文件系统，VFS会给系统内核提供一个调用该文件系统函数的接口。

当用户调用一个文件时，他不需要因为文件属于不同的文件系统而按照不同的方式读取。VFS本身抽象了不同文件系统共同部分，对用户屏蔽了具体的操作，使得用户不用再去关心文件所属的文件系统的问题，实现了各个文件系统的良好兼容。当一个最新推出的文件系统普遍被采用时，LINUX借助VFS的强大功能，可以毫不费力的实现新文件系统在本地的组织运行，同时能不干扰其他已经装配在本地的其他文件系统，可以说以VFS组织文件系统是非常具有可扩展性，并具有优良的发展前景。

硬链接和软链接

（以下转自http://blog.csdn.net/kension/article/details/3796603）

一 链接文件
    链接有两种方式，软链接和硬链接。
　　1 软链接文件
　　软链接又叫符号链接，这个文件包含了另一个文件的路径名。可以是任意文件或目录，可以链接不同文件系统的文件。
    **********链接文件甚至可以链接不存在的文件，这就产生一般称之为"断链"的问题(或曰“现象")，链接文件甚至可以循环链接自己。类似于编程语言中的递归。
　　用ln -s 命令可以生成一个软连接，如下:
　　[root@linux236 test]# ln -s  source_file softlink_file
　　在对符号文件进行读或写操作的时候，系统会自动把该操作转换为对源文件的操作，但删除链接文件时，系统仅仅删除链接文件，而不删除源文件本身。
　　2 硬链接文件
　　info ln 命令告诉您，硬链接是已存在文件的另一个名字(A "hard link" is another name for an existing file)，这多少有些令人困惑。硬连接的命令是
　　ln -d existfile newfile
　　硬链接文件有两个限制
　　1)、不允许给目录创建硬链接；
　　2)、只有在同一文件系统中的文件之间才能创建硬链接。
　对硬链接文件进行读写和删除操作时候，结果和软链接相同（即源文件也被修改）。但如果我们删除硬链接文件的源文件，硬链接文件仍然存在，而且保留了原有的内容。
    这时，系统就“忘记”了它曾经是硬链接文件。而把他当成一个普通文件。
二  两者之间的区别
    硬连接指通过索引节点来进行的连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Number)。
    在Linux中，多个文件名指向同一索引节点是存在的。一般这种连接就是硬连接。硬连接的作用是允许一个文件拥有多个有效路径名，这样用户就可以建立硬连接到重要文件,以防止“误删”。其原因如上所述，因为对应该目录的索引节点有一个以上的连接。只删除一个连接并不影响索引节点本身和其它的连接，只有当最后一个连接被删除后，文件的数据块及目录的连接才会被释放。也就是说，文件才会被真正删除。
    软链接文件有点类似于Windows的快捷方式。它实际上是特殊文件的一种。在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。
三  个人体会
    软链接是另一个文件，作用可以理解为一个指针，作用在这个文件上的操作除了删除都直接转向实际指向文件，由于是一个真实的文件所以占用磁盘空间
    硬链接可以认为不是一个文件，它只是实际文件的一个别名，它的作用是防止真实文件被误操作，给一个文件建立硬链接后，他们互为别名，删除其中任意一个，
    这样用RM命令只会删除该别名，实际文件并不会被删除。只有链接数为0时，才会删除原始文件。

二、系统调用和库函数

　1、系统调用

       系统调用提供的函数如open, close, read, write, ioctl等，需包含头文件unistd.h.以write为例：其函数原型为 size_t write(int fd, const void *buf, size_t nbytes)，其操作对象为文件描述符或文件句柄fd(file descriptor)，要想写一个文件，必须先以可写权限用open系统调用打开一个文件，获得所打开文件的fd,例如 fd=open(\“/dev/video\”, O_RDWR)。fd是一个整型值，每新打开一个文件，所获得的fd为当前最大fd加1.Linux系统默认分配了3个文件描述符值：0-standard input,1-standard output,2-standard error.

　　系统调用通常用于底层文件访问(low-level file access)，例如在驱动程序中对设备文件的直接访问。

　　系统调用是操作系统相关的，因此一般没有跨操作系统的可移植性。

　　系统调用发生在内核空间，因此如果在用户空间的一般应用程序中使用系统调用来进行文件操作，会有用户空间到内核空间切换的开销。事实上，即使在用户空间使用库函数来对文件进行操作，因为文件总是存在于存储介质上，因此不管是读写操作，都是对硬件(存储器)的操作，都必然会引起系统调用。也就是说，库函数对文件的操作实际上是通过系统调用来实现的。例如C库函数fwrite()就是通过write()系统调用来实现的。

　　这样的话，使用库函数也有系统调用的开销，为什么不直接使用系统调用呢？这是因为，读写文件通常是大量的数据(这种大量是相对于底层驱动的系统调用所实现的数据操作单位而言)，这时，使用库函数就可以大大减少系统调用的次数。这一结果又缘于缓冲区技术。在用户空间和内核空间，对文件操作都使用了缓冲区，例如用fwrite写文件，都是先将内容写到用户空间缓冲区，当用户空间缓冲区满或者写操作结束时，才将用户缓冲区的内容写到内核缓冲区，同样的道理，当内核缓冲区满或写结束时才将内核缓冲区内容写到文件对应的硬件媒介。

  2、库函数调用

　　标准C库函数提供的文件操作函数如fopen, fread, fwrite, fclose, fflush, fseek等，需包含头文件stdio.h.以fwrite为例，其函数原型为size_t fwrite(const void *buffer, size_t size, size_t item_num, FILE *pf)，其操作对象为文件指针FILE *pf,要想写一个文件，必须先以可写权限用fopen函数打开一个文件，获得所打开文件的FILE结构指针pf,例如pf=fopen(\“~/proj/filename\”, \“w\”)。实际上，由于库函数对文件的操作最终是通过系统调用实现的，因此，每打开一个文件所获得的FILE结构指针都有一个内核空间的文件描述符fd与之对应。同样有相应的预定义的FILE指针：stdin-standard input,stdout-standard output,stderr-standard error.

       库函数调用通常用于应用程序中对一般文件的访问。库函数调用是系统无关的，因此可移植性好。由于库函数调用是基于C库的，因此也就不可能用于内核空间的驱动程序中对设备的操作。

3.有缓存、无缓存IO

（1和2中包含了对这张图的详细解释）

4.文件描述符

文件操作符的使用：

5.一些常见的系统调用

open,close,read,write，等等

1）open&create：

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode); 
int creat(const char *pathname, mode_t mode);
(Return: a new file descriptor if success; -1 if failure)‏

flags的取值：

    One of O_RDONLY, O_WRONLY or O_RDWRwhich request  opening the file read-only, write-only or read/write, respectively, bitwise-or‟d‏with‏zero‏or‏more‏of‏the‏following:‏
( All defined in /usr/include/fcntl.h)‏
O_APPEND: 每次写都追加到文件的尾端
O_TRUNC: If the file already exists and is a regular file and the open mode allows writing will be truncated （截短）to length 0.
O_CREAT: If the file does not exist it will be created.
O_EXCL:如果文件已存在，则出错；必须与O_CREAT一起使用

 “creat”‏function:‏equivalent ‏to‏ open ‏with ‏flags ‏equal‏  to O_CREAT|O_WRONLY|O_TRUNC

mode的取值：

“mode”:‏specifies‏ the‏ permissions‏  to‏  use in case a new file is created.

（这个取值与前面的那种777之类的一起记，简单）

2）close：

Close a file descriptor

#include <unistd.h>
int close(int fd);
(Return: 0 if success; -1 if failure)‏

3）read&write：

Read from a file descriptor
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
(返回值: 读到的字节数，若已到文件尾为0，若出错为-1)‏
 Write to a file descriptor
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
(返回值: 若成功为已写的字节数，若出错为-1)‏

exmaple：

while ((n = read(STDIN_FILENO, buf, BUFSIZE)) > 0)‏
    if (write(STDOUT_FILENO, buf, n) != n)‏
          err_sys(“write‏error”);
 if (n<0)‏
     err_sys(“read‏error”);

4）lseek

功 能: 移动文件读/写指针 

所有打开的文件都有一个当前文件偏移量（current file offset），以下简称为 cfo。cfo 通常是一个非负整数，用于表明文件开始处到文件当前位置的字节数。读写操作通常开始于 cfo，并且使 cfo 增大，增量为读写的字节数。文件被打开时，cfo 会被初始化为 0，除非使用了 O_APPEND 。使用 lseek 函数可以改变文件的 cfo 。

参数 offset 的含义取决于参数 whence：

　　1. 如果 whence 是 SEEK_SET，文件偏移量将被设置为 offset。

　　2. 如果 whence 是 SEEK_CUR，文件偏移量将被设置为 cfo 加上 offset，

　　offset 可以为正也可以为负。

　　3. 如果 whence 是 SEEK_END，文件偏移量将被设置为文件长度加上 offset，

　　offset 可以为正也可以为负。

返回值：新的偏移量（成功），-1（失败）

5)dup/dup2

dup 和 dup2 都可以用来复制一个现存的文件描述符。经常用来重新定向进程的 STDIN, STDOUT, STDERR。

dup 函数 
dup 函数定义在 <unistd.h> 中，函数原形为：int dup ( int filedes ) ; 

函数返回一个新的描述符，这个新的描述符是传给它的描述符的拷贝，若出错则返回 －1。由dup返回的新文件描述符一定是当前可用文件描述符中的最小数值。这函数返回的新文件描述符与参数 filedes 共享同一个文件数据结构。

使用例子：

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

int main( int argc, char* argv[] ){ 
int fd= open( "/home/darren/data.dat", O_CREAT| O_RDWR| O_TRUNC, S_IRUSR| S_IWUSR ); 
if( fd< 0 ){ 
printf("Open Error!!\n"); 
return 0; 
}

int nfd= dup( fd ); 
if( nfd< 0 ){ 
printf("Error!!\n"); 
return 0; 
}

char buf[1000]; 
int n;

while( (n= read( STDIN_FILENO, buf, 1000 ))> 0 ) 
if( write( nfd, buf, n )!= n ){ 
printf("Write Error!!\n"); 
return 0; 
}

return 0; 
}

上面代码中，nfd 拷贝了 fd，所以 write ( nfd, buf, n ) 这语句写到 nfd 所代表的文件时也就是写到 fd 所代表的文件。程序执行完后可以在相应的目录的 data.dat 看到输出。

dup2 函数 
dup2 函数定义在 <unistd.h> 中，函数原形为：int dup2( int filedes, int filedes2 ) 

同样，函数返回一个新的文件描述符，若出错则返回 －1。与 dup 不同的是，dup2 可以用 filedes2 参数指定新描述符的数值。如果 filedes2 已经打开,则先将其关闭。如若 filedes 等于 filedes2 , 则 dup2 返回 filedes2 , 而不关闭它。同样，返回的新文件描述符与参数 filedes 共享同一个文件数据结构。

6)fcntl

重点是文件锁，在本文最后有详细讲解。

5.一些常见的库函数调用

打开关闭、读写、flush（具体实例看PDF CH3-1 p44-48）

1）open

2）close

3）每次一个字符的IO

4）每次一行的IO

5）直接IO（二进制IO）

6）格式化IO

7）reposition

8）flush

别的还是看PDF吧，多的我都不想动了。日。

6.C库File * 和系统调用中文件描述符的区别

  文件描述符：在linux系统中，设备也是以文件的形式存在，要对该设备进行操作就必须先打开这个文件，打开文件就会获得文件描述符，它是个很小的正整数。每个进程在PCB（Process Control Block）中保存着一份文件描述符表，文件描述符就是这个表的索引，每个表项都有一个指向已打开文件的指针。文件描述符的优点：兼容POSIX标准，许多Linux和UNIX系统调用都依赖于它。文件描述符的缺点：不能移植到UNIX以外的系统上去，也不直观。
       文件指针：C语言中使用的是文件指针而不是文件描述符做为I/O的句柄。文件指针指向进程用户区中的一个被称为FILE结构的数据结构。FILE结构包括一个缓冲区和一个文件描述符。而文件描述符是文件描述符表的一个索引，因此从某种意义上说文件指针就是句柄的句柄（在Windows系统上，文件描述符被称作文件句柄）。FILE *中除了包含了fd信息，还包含了IO缓冲，是C标准形式，所以FILE *比fd更适合跨平台，应该多用fopen在，少用open。

相互转化：

 确定流使用的底层文件描述符
#include <stdio.h>
int fileno(FILE *fp);
 根据已打开的文件描述符创建一个流
#include <stdio.h>
FILE *fdopen(int fildes, const char *mode);

7.缓存的三个类型

block buffered (fully buffered)‏
line buffered
unbuffered

setbuf, setvbuf functions
#include <stdio.h>
void setbuf(FILE *stream, char *buf);
int setvbuf(FILE *stream, char *buf, int mode, size_t 
size);

type取值：_IOFBF(满缓冲）_IOLBF(行缓冲）
_IONBF(无缓冲）

三、文件锁

1.文件锁的类型

记录锁
劝告锁（检查，加锁有应用程序自己控制）
强制锁（检查，加锁由内核控制，影响[open() read() write()]等）
共享锁
排他锁

特殊类型
  共享模式强制锁
  租借锁

Linux 支持的文件锁技术主要包括劝告锁（advisory lock）和强制锁（mandatory lock）这两种。

劝告锁：劝告锁是一种协同工作的锁。对于这一种锁来说，内核只提供加锁以及检测文件是否已经加锁的手段，但是内核并不参与锁的控制和协调。也就是说，如果有进程不遵守“游戏规则”，不检查目标文件是否已经由别的进程加了锁就往其中写入数据，那么内核是不会加以阻拦的。因此，劝告锁并不能阻止进程对文件的访问，而只能依靠各个进程在访问文件之前检查该文件是否已经被其他进程加锁来实现并发控制。进程需要事先对锁的状态做一个约定，并根据锁的当前状态和相互关系来确定其他进程是否能对文件执行指定的操作。从这点上来说，劝告锁的工作方式与使用信号量保护临界区的方式非常类似。劝告锁可以对文件的任意一个部分进行加锁，也可以对整个文件进行加锁，甚至可以对文件将来增大的部分也进行加锁。由于进程可以选择对文件的某个部分进行加锁，所以一个进程可以获得关于某个文件不同部分的多个锁。

强制锁:是一种内核强制采用的文件锁，它是从 System V Release 3 开始引入的。每当有系统调用 open()、read() 以及write() 发生的时候，内核都要检查并确保这些系统调用不会违反在所访问文件上加的强制锁约束。也就是说，如果有进程不遵守游戏规则，硬要往加了锁的文件中写入内容，内核就会加以阻拦：

共享模式强制锁和租借锁：

这两种文件锁可以被看成是强制锁的两种变种形式。共享模式强制锁可以用于某些私有网络文件系统，如果某个文件被加上了共享模式强制锁，那么其他进程打开该文件的时候不能与该文件的共享模式强制锁所设置的访问模式相冲突。但是由于可移植性不好，因此并不建议使用这种锁。

采用强制锁之后，如果一个进程对某个文件拥有写锁，只要它不释放这个锁，就会导致访问该文件的其他进程全部被阻塞或不断失败重试；即使该进程只拥有读锁，也会造成后续更新该文件的进程的阻塞。为了解决这个问题，Linux 中采用了一种新型的租借锁。

当进程尝试打开一个被租借锁保护的文件时，该进程会被阻塞，同时，在一定时间内拥有该文件租借锁的进程会收到一个信号。收到信号之后，拥有该文件租借锁的进程会首先更新文件，从而保证了文件内容的一致性，接着，该进程释放这个租借锁。如果拥有租借锁的进程在一定的时间间隔内没有完成工作，内核就会自动删除这个租借锁或者将该锁进行降级，从而允许被阻塞的进程继续工作。

or：

文件锁包括建议性锁和强制性锁。建议性锁要求每个上锁文件的进程都要检查是否有锁存在，并且尊重己有的锁。在一般情况下，内核和系统都不使用建议性锁。强制性锁是由内核执行的锁，当文件上锁进行写入操作时，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。

在Linux中，实现文件上锁的函数有flock()和fcntl()，其中flock()用于对文件施加建议性锁，而fcntl()不仅可以施加建议性锁，还可以施加强制性锁，还能对文件的某一记录进行上锁，也就是记录锁。
记录锁又分为读取锁和写入锁。读取锁又称共享锁，能使多个进程都在文件的同一部分建立读取锁。写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。在文件的同一部分不能同时建立读取锁和写入锁。

2.fcntl()函数格式

所需头文件：#include<sys/types.h>,#include<unistd.h>,include<fcntl.h>

函数原型：int fcntl(int fd,cmd,struct flock *lock)

函数参数：

fd：文件描述符

cmd：

 F_DUPFD：复制文件描述符
 F_GETFD：获得fd的close-on-exec标志，若标志未设置，则文件经过exec函数之后仍保持打开状态。
 F_SETFD：设置close-on-exec标志，该标志以参数arg的FD_CLOEXEC位决定。
 F_GETFL：得到open设置的标志
 F_SETFL：改变open设置的标志
 F_GETFK：根据lock描述，决定是否上文件锁
 F_SETFK：设置lock描述的文件锁
 F_SETLKW：这是F_SETLK的阻塞版本（命令名中的W表示等待（wait））。如果存在其它锁，则调用进程睡眠；如果捕捉到信号则睡眠中断
 F_GETOWN：检索将收到SIGIO和SIGURG信号的进程号或进程组号
 F_SETOWN：设置进程号或进程组号

F_GETLK/F_SETLK/F_SETLKW: Get/set the file lock

lock: 结构为flock，记录锁的具体状态

struct flock
{
   short l_type;
   off_t l_start;
   short l_whence;
   off_t l_len;
   pid_t l_pid;
}

Lock结构变量取值：

l_type：F_RDLCK：读取锁（共享锁）
             F_WRLCK：写入锁（排斥锁）
             F_UNLCK：解锁
l_start：相对位移量（字节）
l_whence:相对位移量的起点（同lseek的whence）：
         SEEK_SET：当前位置为文件开头，新位置为偏移量的大小
         SEEK_CUR：当前位置为文件指针位置，新位置为当前位置加上偏移量
         SEEK_END：当前位置为文件的结尾，新位置为文件的大小加上偏移量大小
l_len：加锁区域长度

小技巧：为了锁定整个文件，通常的做法是将l_start设置为0，l_whence设置为SEEK_SET,l_len设置为0

3.fcntl()函数实例

int lock_set(int fd,int type)
{
  struct flock lock;
  lock.l_type=type;
  lock.l_start=0;
  lock.l_whence=SEEK_SET;
  lock.l_len=0;
  lock.l_pid=-1;

  fcntl(fd,F_GETLK,&lock);
  if(lock.l_type!=F_UNLCK)
  {
   
    if(lock.l_type==F_RDLCK)          //该文件已有读取锁
    {
      printf("Read lock already set by %d\n",lock.l_pid);
    }
    else if(lock.l_type==F_WRLCK)    //该文件已有写入锁
    {
      printf("Write lock already set by %d\n",lock.l_pid);
    }
  }

 
  lock.l_type=type;

 
  if((fcntl(fd,F_SETLKW,&lock))<0)
  {
    printf("Lock failed:type=%d\n",lock.l_type);
    return 1;
  }

  switch(lock.l_type)
  {
    case F_RDLCK:
    {
      printf("Read lock set by %d\n",getpid());
    }
    break;

    case F_WRLCK:
    {
      printf("Write lock set by %d\n",getpid());
    }
    break;

    case F_UNLCK:
    {
      printf("Release lock by %d\n",getpid());
      return 1;
    }
    break;

   default:
   break;
  }

  return 0;

}

 

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/file.h>
#include "lock_set.c"

int main(void)
{
  int fd;

 
  fd=open("hello",O_RDWR|O_CREAT,0644);
  if(fd<0)
  {
    printf("Open file error!!\n");
    exit(1);
  }

 
  lock_set(fd,F_WRLCK);
  getchar();
 
  lock_set(fd,F_UNLCK);
  getchar();
  close(fd);
  exit(0);
}

4.其它封锁命令
 lockf函数
#include <sys/file.h>
int lockf(int fd, int cmd, off_t len);