ls 命令可以用于显示目录的内容，也可以显示文件的属性，比如节点、文件种类、权限、拥有者、大小、创建时间等；在目前最新版本的Linux中dir和ls命令的用法是一样的；有兴趣的不仿尝试一下；

1.1 ls 的基础语法和参数；

语法格式：

参数：

在这里，位于[]之内的都是可选的。如果您只输入ls ，就会列出用户所处当前目录的所有文件，用短格式输出，但不会列出隐藏文件。

判断用户所处目录的命令是pwd，也就是

1.2 ls 的参数示例应用；

1.21 列出目录下所有文件，包含或不包含隐藏文件，-a 参数及-l参数的运用；

如果不接目录名，表示输出当前用户所处目录内的所有文件，包括隐藏文件；

列出某一目录下的的文件或目录，但不包括隐藏文件，我们只用-l参数

比如：

说明：如果以长格式输入，总共显示出八段内容：

第一段文件种类及权限，也就是类似这样的-rw-r--r-- ，我们在前面讲到，如果在这段中，第一字符表示文件的类型，如果出现-，表示普通文件。如果是d开头的就是目录。在这个例子中，123.txt是普通文件，而mkuml-2004.07.17就是一个目录。关于文件的种类，请参考 ：
rw-r--r--是权限位，我们在以后的教程中会讲到。
第二段 硬链接个数（文件系增加一个硬链接，数字会增加1，默认从1开始，1表示无硬链接文件，如果是一个目录，它的默认值应该是2。目录是不能做硬链接的）
如果我们不以长格式输出的话，可以把参数省略；
第三段 文件或目录所占用的字节数，如果您想用K来表示，请用ls -lh /root
第四段 最后访问日期
第五段 最后访问时间
第六段 文件名

1.22 仅查看目录的属性的-d参数的运用示例；

1.23 查看文件或目录的inode节点，-i参数的运用；

查看文件或目录的节点，我们要用到i参数。如果节点相同，能确认他们是相同的文件，是通过通过ln 创建的硬链接文件；链接接有何用？如果您想把一个文件复制时保持原文件或目录的节点、大小、权限以及访问（或修改）时间都和原文件一致的文件。必须通过硬链接来实现，用cp命令是不可能实现的。

比如：

我们看一下kernel00.rpm 、kernel.rpm 和 kernel-2.6.15-1.2025_FC5.i686.rpm 是不是节点相同？？他们的大小是不是一样，他们的访问日期是不是一样？只是他们的文件名不一样。文件名不一样没有关系，这能证明其中两个文件是由另一个文件通过ln 创建而成。

您可以尝试着用cp 把 kernel-2.6.15-1.2025_FC5.i686.rpm 复制为kernel002.rpm ，看看能不能保持节点相同？

不是是kernel002.rpm 的节点和 kernel-2.6.15-1.2025_FC5.i686.rpm 不一样了？

1.24 关于排序的参数的应用；

ls 显示目录的内容时，会将文件按a到z的字母顺序显示，优先级如下；

也就是说如果不加任何排序的参数，文件名第一个字母是数字的，将优先显示；其次才是A－Z，然后才是a-z；下面是几个排序的参数，大家练习一下就知道了；

举例

举例：

1.25 递归显示目录的文件，-R参数的应用；

递归显示目录下的所有文件，如果该目录下有子目录，也会把子目录的文件一并显示出来。

比如

注：也就是把Linux下/根目录下的所有文件显示出来，但不会显示隐藏文件。自己试着输入上面的命令就知道怎么回事了。

1.26 关于ls 输出内容在终端显示颜色的参数 --color；

在一般的情况下，ls输出内容是有颜色的，比如目录是蓝色，压缩文件是红字的显示。如果没有颜色，可以加上参数。当然也可以去掉颜色。

举例：

如果您的终端或控制台输出的内容没有颜色，可以自己来定义。在当前用户的家目录下的.bashrc 中加入下面的一行；

1.27 ls的-F参数的示例；

1.3 通配符在ls命令中的应用；

举例：

比如我们显示以k开头的所有文件，在/root目录中的；

我们显示以数字开头的所有文件；

下面是一个?通配符的示例：

1.4 获得ls 的帮助；

ls 的用法比较简单，至于更详细的参考，还是查man和help。遇到不会的，就查手册，我也是这么做的。

2、移动文件或目录的命令 mv ；

mv 命令是用来移动文件或目录的；有以下几种格式；

参数-i ，表示人机交互模式；提示警告信息；

举例：

mv 也能和通配符结合一起使用，这样能把相似特征的文件移动到某处；

举例：比如移动以数字开头的文件或目录到 root目录下的tmp目录中；

3、文件或目录的复制工具cp ；

3.1 cp 的语法和参数

注：参数是可选的，常用参数比如 -r,-R,-p,-i ；

参数说明（部份）

-a 等同于-dpR参数一起使用；在复制过程中尽可能保留源文件或目录的属性；
-b 给被覆盖的文件做备份。比如我们把file1 复制到file2时，如果file2存在，我们把file2覆盖掉，用这个参数就能同时生成一个file2~的文件，注意文件名后有~结尾
-d 不间接引用符号链接，保持源文件和目标文件之间的硬链接关系；
-f 删除已存在的目标文件；
-i 覆盖已存在的目标文件之前给出警告提示，这是人机交互的选项；
-l 建立文件硬链接，而不是复制；
-p 保存源文件或目录的最后修改时间和模式，比如要保持目标目录或文件的属主、组、权限和最后访问（或修改）时间；
-R 复制目录时，包括淅目录下所有的子目录和文件；
-s 建立源文件的符号链接，而不是复制源文件。源文件名必须用绝对路径；
-r 复制目录时，包括淅目录下所有的子目录和文件；-r选项不同于-R之处在于 尝试打开目的地文件前先删除已存在的目的地文件
-i 人机交互模式，显法覆盖已存在的文件或目录的警告信息；
-v 在复制之前，输出每个文件的名字；
--help 查看帮助 ；

3.2 示例说明cp应用；

3.21 参数-i的示例；

注：人机交互在数-i的运用；如果源文件复制到目标文件，如果目标文件存在，则提示警告；

3.22 参数-a的示例及说明；

把源目录复制到另外的一个目标，相当于克隆了一个目录，源目录和目标目录在用户组、权限及修改或访问时间保持一致；

注：复制目录mydir 到youdir ，如果yourdir目录不存在，则创建。并且把mydir中所有的文件下级子目录都复制到 yourdir目录中。也就是说mydir目录的文件和youdir是一样的。-a 参数等同于-dpR，并且源目录和目标目录的属性（用户组、权限、最后访问及修改时间）都一致；

3.23 参数-b的示例应用；

把源文件复制为目标文件；并且尝试-b参数的运用；

3.24 把多个文件复制到目录目录中示例；

比如我们把位于用户当前目录下的fonts.dir、Kernel.rpm和Plist文件，复制到当前用户所处的目录下的sun目录中；

注：如果您想把多个目录或文件复制到目标目录时，您得加参数 -R

3.25 复制目录时-R参数的应用；

复制一个目录到另一个目录时，我们要用到 -r或-R 或-a ， 如果目标目录不存在，则创建它，如果目标目录存在，则复制源目录到目标目录之下；看看-a和-R或-r有什么不同？尝试看看；

比如我们在用户当前操作的目录中，有mydir目录，我们想把mydir复制为medir（在复制之前medir是不存在的）。

如果您把-R参数换成-a参数，会有什么不同？看看前面的例子所说的；

4、 目录创建工具mkdir和删除空目录工具rmdir；

4.1 mkdir 是目录创建工具；

4.11 mkdir语法格式及参数；

语法格式

参数常用的如下：

-m 在创建目录时要授其权限，要和chmod的授权格式；
-p 如果中间目录不存在，则创建它

4.12 参数 -p 的应用示例

我们要创建一个目录linuxsir，并且linuxsir目录下包含子目录sirdoc，sirdoc目录下还有 redhat目录；

举例： -m 参数的应用示例；

我们以不同的权限来创建目录，然后查看我们所创建目录的属性；这要涉及到chown 来改变目录的权限的格式。我们会在以后讲到chown改变目录或文件的权限。在这里不同的是，在目录创建之时就给其授权了；

4.2 删除空目录工具 rmdir 和rm ；

rmdir 是用来删除空目录用的，如果目录中有文件或子目录，必须先删除文件或子目录，其语法格式如下：

rmdir 参数常用的有：

-p 删除目录时是一级一级的时行的，值得注意的是，首先从最里面的目录开始。下面是一个例子；

rmdir 所删除的目录，每级目录中都是空的，没有其它的文件。如果任何一级的目录有文件，也不能删除。这时您要用到rm -rf 命令强制删除。不过用rm -rf 删除时有点不安全，还是用rf -ri 比较好一点，因为在删除的时候，会有警告提示。这对于安全操作来说是很重要的；

5、创建一个空文件的工具：用 touch、echo、cat等工具；

有时我们为了方便，可能在控制台或终端下创建一个不存在的空文件，然后我们再用编辑器来编辑它；创建空文件有时还有点用。说说也无妨。我们在这里用touch、ech0及cat 工具。其实这些工具，创建文件只是他们的一个小小的功能，我们以后再介绍这些工具，先说他们创建文件的功能。

注意：创建这些文件，在我们操作创建文件之前，这些文件在用户当前操作目录下是不存在的，我们在这里只是创建一个新的文件名，并且它里面没有任何空容的；

6、删除文件工具rm；

rm 是用来删除一个或多个文件的工具，并且能用于删除非空目录。我们前面提到了可以加参数-rf 就可以强制删除一个非空目录。

rm的语法格式；

rm 常用参数：

比如我们想删除mydir目录及所有下级目录和文件，要有提示的警告信息，可以用-r参数和-i参数的组合；如果您想终止rm命令，请按ctrl+c组合健退出rm；

如果您想没有任何警告信息的删除mydir目录下的所有文件及子目录，可以用-r和-f参数的组合；

7、修改文件名工具 mv

mv 可以移动一个文件（或目录）到另一个文件（或目录），如果文件（或目录）不存在，则创建它。其实mv 这个过程也可以理解为改名过程，所以说mv工具能修改文件名和目录名。

注意：新文件名或目录名应该不能与现有文件名（或目录名）同名。

举例：

再看一例mv 修改目录的。当然mv是把文件（或目录）从一个地方移到另一个地方。如果另一地方没有和源文件（或目录）同名的，就创建。这也相当于改名；

构建linux下IDE环境--Eclipse篇

在多任务操作系统环境中，如果一个进程尝试对正在被其他进程读取的文件进行写操作，可能会导致正在进行读操作的进程读取到一些被破坏或者不完整的数据；如果两个进程并发对同一个文件进行写操作，可能会导致该文件遭到破坏。因此，为了避免发生这种问题，必须要采用某种机制来解决多个进程并发访问同一个文件时所面临的同步问题，由此而产生了文件加锁方面的技术。

早期的 UNIX 系统只支持对整个文件进行加锁，因此无法运行数据库之类的程序，因为此类程序需要实现记录级的加锁。在 System V Release 3 中，通过 fcntl 提供了记录级的加锁，此后发展成为 POSIX 标准的一部分。本文将基于 2.6.23 版本的内核来探讨 Linux 中文件锁的相关技术。

Linux 中的文件锁

Linux 支持的文件锁技术主要包括劝告锁（advisory lock）和强制锁（mandatory lock）这两种。此外，Linux 中还引入了两种强制锁的变种形式：共享模式强制锁（share-mode mandatory lock）和租借锁（lease）。

在 Linux 中，不论进程是在使用劝告锁还是强制锁，它都可以同时使用共享锁和排他锁（又称为读锁和写锁）。多个共享锁之间不会相互干扰，多个进程在同一时刻可以对同一个文件加共享锁。但是，如果一个进程对该文件加了排他锁，那么其他进程则无权再对该文件加共享锁或者排他锁，直到该排他锁被释放。所以，对于同一个文件来说，它可以同时拥有很多读者，但是在某一特定时刻，它只能拥有一个写者，它们之间的兼容关系如表 1 所示。

劝告锁

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

劝告锁可以对文件的任意一个部分进行加锁，也可以对整个文件进行加锁，甚至可以对文件将来增大的部分也进行加锁。由于进程可以选择对文件的某个部分进行加锁，所以一个进程可以获得关于某个文件不同部分的多个锁。

强制锁

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

如果一个文件已经被加上了读锁或者共享锁，那么其他进程再对这个文件进行写操作就会被内核阻止；

如果一个文件已经被加上了写锁或者排他锁，那么其他进程再对这个文件进行读取或者写操作就会被内核阻止。

如果其他进程试图访问一个已经加有强制锁的文件，进程行为取决于所执行的操作模式和文件锁的类型，归纳如表 2 所示：

需要注意的是，如果要访问的文件的锁类型与要执行的操作存在冲突，那么采用阻塞读/写操作的进程会被阻塞，而采用非阻塞读/写操作的进程则不会阻塞，而是立即返回 EAGAIN。

另外，unlink() 系统调用并不会受到强制锁的影响，原因在于一个文件可能存在多个硬链接，此时删除文件时并不会修改文件本身的内容，而是只会改变其父目录中 dentry 的内容。

然而，在有些应用中并不适合使用强制锁，所以索引节点结构中的 i_flags 字段中定义了一个标志位MS_MANDLOCK用于有选择地允许或者不允许对一个文件使用强制锁。在 super_block 结构中，也可以将 s_flags 这个标志为设置为1或者0，用以表示整个设备上的文件是否允许使用强制锁。

要想对一个文件采用强制锁，必须按照以下步骤执行：

使用 -o mand 选项来挂载文件系统。这样在执行 mount() 系统调用时，会传入 MS_MANDLOCK 标记，从而将 super_block 结构中的 s_flags 设置为 1，用来表示在这个文件系统上可以采用强制锁。例如：

# mount -o mand /dev/sdb7 /mnt
            # mount | grep mnt
            /dev/sdb7 on /mnt type ext3 (rw,mand)
            

1.修改要加强制锁的文件的权限：设置 SGID 位，并清除组可执行位。这种组合通常来说是毫无意义的，系统用来表示该文件被加了强制锁。例如：

# touch /mnt/testfile
            # ls -l /mnt/testfile
            -rw-r--r-- 1 root root 0 Jun 22 14:43 /mnt/testfile
            # chmod g+s /mnt/testfile
            # chmod g-x /mnt/testfile
            # ls -l /mnt/testfile
            -rw-r-Sr-- 1 root root 0 Jun 22 14:43 /mnt/testfile
            

2.使用 fcntl() 系统调用对该文件进行加锁或解锁操作。

1.3. 共享模式锁

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

租借锁

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

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

系统默认的这段间隔时间是 45 秒钟，定义如下：

		137 int lease_break_time = 45;
            

这个参数可以通过修改 /proc/sys/fs/lease-break-time 进行调节（当然，/proc/sys/fs/leases-enable 必须为 1 才行）。

Linux 内核中关于文件锁的实现

在 Linux 内核中，所有类型的文件锁都是由数据结构 file_lock 来描述的，file_lock 结构是在 文件中定义的，内容如下所示：

            811 struct file_lock {
            812         struct file_lock *fl_next;      /* singly linked list for this inode  */
            813         struct list_head fl_link;       /* doubly linked list of all locks */
            814         struct list_head fl_block;      /* circular list of blocked processes */
            815         fl_owner_t fl_owner;
            816         unsigned int fl_pid;
            817         wait_queue_head_t fl_wait;
            818         struct file *fl_file;
            819         unsigned char fl_flags;
            820         unsigned char fl_type;
            821         loff_t fl_start;
            822         loff_t fl_end;
            823
            824         struct fasync_struct *  fl_fasync; /* for lease break notifications */
            825         unsigned long fl_break_time;    /* for nonblocking lease breaks */
            826
            827         struct file_lock_operations *fl_ops;    /* Callbacks for filesystems */
            828      struct lock_manager_operations *fl_lmops;       /* Callbacks for lockmanagers */
            829         union {
            830                 struct nfs_lock_info    nfs_fl;
            831                 struct nfs4_lock_info   nfs4_fl;
            832             struct {
            833                  struct list_head link;  /* link in AFS vnode's pending_locks list */
            834                  int state;              /* state of grant or error if -ve */
            835                 } afs;
            836         } fl_u;
            837 };
            

表 3 简单描述了 file_lock 结构中的各个字段所表示的含义。

一个 file_lock 结构就是一把“锁”，结构中的 fl_file 就指向目标文件的 file 结构，而 fl_start 和 fl_end 则确定了该文件要加锁的一个区域。当进程发出系统调用来请求对某个文件加排他锁时，如果这个文件上已经加上了共享锁，那么排他锁请求不能被立即满足，这个进程必须先要被阻塞。这样，这个进程就被放进了等待队列，file_lock 结构中的 fl_wait 字段就指向这个等待队列。指向磁盘上相同文件的所有 file_lock 结构会被链接成一个单链表 file_lock_list，索引节点结构中的 i_flock 字段会指向该单链表结构的首元素，fl_next 用于指向该链表中的下一个元素；当前系统中所有被请求，但是未被允许的锁被串成一个链表：blocked_list。fl_link 字段指向这两个列表其中一个。对于被阻塞列表（blocked_list）上的每一个锁结构来说，fl_next 字段指向与该锁产生冲突的当前正在使用的锁。所有在等待同一个锁的那些锁会被链接起来，这就需要用到字段 fl_block，新来的等待者会被加入到等待列表的尾部。 此外，fl_type 表示锁的性质，如读、写。fl_flags 是一些标志位，在 linux 2.6中，这些标志位的定义如下所示：

            773 #define FL_POSIX        1
            774 #define FL_FLOCK        2
            775 #define FL_ACCESS       8       /* not trying to lock, just looking */
            776 #define FL_EXISTS       16      /* when unlocking, test for existence */
            777 #define FL_LEASE        32      /* lease held on this file */
            778 #define FL_CLOSE        64      /* unlock on close */
            779 #define FL_SLEEP        128     /* A blocking lock */
            

FL_POSIX 锁是通过系统调用 fcntl() 创建的；而 FL_FLOCK 锁是通过系统调用 flock()创建的（详细内容请参见后文中的介绍）。FL_FLOCK 锁永远都和一个文件对象相关联，打开这个文件的进程拥有该 FL_FLOCK 锁。当一个锁被请求或者允许的时候，内核就会把这个进程在同一个文件上的锁都替换掉。FL_POSIX 锁则一直与一个进程以及一个索引节点相关联。当进程死亡或者文件描述符被关闭的时候，这个锁会被自动释放。

对于强制锁来说，在 Linux 中，内核提供了 inline 函数 locks_verify_locked() 用于检测目标文件或者目标文件所在的设备是否允许使用强制锁，并且检查该设备是否已经加上了锁，相关函数如下所示：

            166 #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
            173 #define IS_MANDLOCK(inode)      __IS_FLG(inode, MS_MANDLOCK)
            1047 /**
            1048  * locks_mandatory_locked - Check for an active lock
            1049  * @inode: the file to check
            1050  *
            1051  * Searches the inode's list of locks to find any POSIX locks which conflict.
            1052  * This function is called from locks_verify_locked() only.
            1053  */
            1054 int locks_mandatory_locked(struct inode *inode)
            1055 {
            1056         fl_owner_t owner = current->files;
            1057         struct file_lock *fl;
            1058
            1059         /*
            1060          * Search the lock list for this inode for any POSIX locks.
            1061          */
            1062         lock_kernel();
            1063         for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
            1064                 if (!IS_POSIX(fl))
            1065                         continue;
            1066                 if (fl->fl_owner != owner)
            1067                         break;
            1068         }
            1069         unlock_kernel();
            1070         return fl ? -EAGAIN : 0;
            1071 }
            1368 /*
            1369  * Candidates for mandatory locking have the setgid bit set
            1370  * but no group execute bit -  an otherwise meaningless combination.
            1371  */
            1372 #define MANDATORY_LOCK(inode) \
            1373         (IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
            1374
            1375 static inline int locks_verify_locked(struct inode *inode)
            1376 {
            1377         if (MANDATORY_LOCK(inode))
            1378                 return locks_mandatory_locked(inode);
            1379         return 0;
            1380 }
            

这里，函数 locks_verify_locked() 利用宏 MANDATORY_LOCK 来检测目标文件是否允许加锁，条件包括：该文件所在的设备的 super_block 结构中的 s_flags 必须被置为 1，该文件的 SGID 被置为 1 而且同组可执行位被清 0。如果允许，则调用函数locks_mandatory_locked()，该函数从索引节点的锁列表中查找是否存在有与其相冲突的锁，即是否已经加上了锁。

Linux 中关于文件锁的系统调用

这里介绍在 Linux 中与文件锁关系密切的两个系统调用：flock() 和 fcntl()。劝告锁既可以通过系统调用 flock() 来实现，也可以通过系统调用 fcntl() 来实现。flock() 系统调用是从 BSD 中衍生出来的，在传统的类 UNIX 操作系统中，系统调用flock() 只适用于劝告锁。但是，Linux 2.6内核利用系统调用 flock() 实现了我们前面提到的特殊的强制锁：共享模式强制锁。另外，flock() 只能实现对整个文件进行加锁，而不能实现记录级的加锁。系统调用fcntl() 符合 POSIX 标准的文件锁实现，它也是非常强大的文件锁，fcntl() 可以实现对纪录进行加锁。

flock()

flock() 的函数原型如下所示：

          int flock(int fd, int operation);
            

其中，参数 fd 表示文件描述符；参数 operation 指定要进行的锁操作，该参数的取值有如下几种：LOCK_SH， LOCK_EX， LOCK_UN 和 LOCK_MANDphost2008-07-03T00:00:00

man page 里面没有提到，其各自的意思如下所示：

• LOCK_SH：表示要创建一个共享锁，在任意时间内，一个文件的共享锁可以被多个进程拥有
• LOCK_EX：表示创建一个排他锁，在任意时间内，一个文件的排他锁只能被一个进程拥有
• LOCK_UN：表示删除该进程创建的锁
• LOCK_MAND：它主要是用于共享模式强制锁，它可以与 LOCK_READ 或者 LOCK_WRITE 联合起来使用，从而表示是否允许并发的读操作或者并发的写操作（尽管在 flock() 的手册页中没有介绍 LOCK_MAND，但是阅读内核源代码就会发现，这在内核中已经实现了）

通常情况下，如果加锁请求不能被立即满足，那么系统调用 flock() 会阻塞当前进程。比如，进程想要请求一个排他锁，但此时，已经由其他进程获取了这个锁，那么该进程将会被阻塞。如果想要在没有获得这个排他锁的情况下不阻塞该进程，可以将 LOCK_NB 和 LOCK_SH 或者 LOCK_EX 联合使用，那么系统就不会阻塞该进程。flock() 所加的锁会对整个文件起作用。

fcntl()

fcntl() 函数的功能很多，可以改变已打开的文件的性质，本文中只是介绍其与获取/设置文件锁有关的功能。fcntl() 的函数原型如下所示：

       int fcntl (int fd, int cmd, struct flock *lock);
            

其中，参数 fd 表示文件描述符；参数 cmd 指定要进行的锁操作，由于 fcntl() 函数功能比较多，这里先介绍与文件锁相关的三个取值 F_GETLK、F_SETLK 以及 F_SETLKW。这三个值均与 flock 结构有关。flock 结构如下所示：

            struct flock {
            ...
            short l_type;    /* Type of lock: F_RDLCK,
            F_WRLCK, F_UNLCK */
            short l_whence;  /* How to interpret l_start:
            SEEK_SET, SEEK_CUR, SEEK_END */
            off_t l_start;   /* Starting offset for lock */
            off_t l_len;     /* Number of bytes to lock */
            pid_t l_pid;     /* PID of process blocking our lock
            (F_GETLK only) */
            ...
            };
            

在 flock 结构中，l_type 用来指明创建的是共享锁还是排他锁，其取值有三种：F_RDLCK（共享锁）、F_WRLCK（排他锁）和F_UNLCK（删除之前建立的锁）；l_pid 指明了该锁的拥有者；l_whence、l_start 和l_end 这些字段指明了进程需要对文件的哪个区域进行加锁，这个区域是一个连续的字节集合。因此，进程可以对同一个文件的不同部分加不同的锁。l_whence 必须是 SEEK_SET、SEEK_CUR 或 SEEK_END 这几个值中的一个，它们分别对应着文件头、当前位置和文件尾。l_whence 定义了相对于 l_start 的偏移量，l_start 是从文件开始计算的。

可以执行的操作包括：

• F_GETLK：进程可以通过它来获取通过 fd 打开的那个文件的加锁信息。执行该操作时，lock 指向的结构中就保存了希望对文件加的锁（或者说要查询的锁）。如果确实存在这样一把锁，它阻止 lock 指向的 flock 结构所给出的锁描述符，则把现存的锁的信息写到 lock 指向的 flock 结构中，并将该锁拥有者的 PID 写入 l_pid 字段中，然后返回；否则，就将 lock 指向的 flock 结构中的 l_type 设置为 F_UNLCK，并保持 flock 结构中其他信息不变返回，而不会对该文件真正加锁。
• F_SETLK：进程用它来对文件的某个区域进行加锁（l_type的值为 F_RDLCK 或 F_WRLCK）或者删除锁（l_type 的值为F_UNLCK），如果有其他锁阻止该锁被建立，那么 fcntl() 就出错返回
• F_SETLKW：与 F_SETLK 类似，唯一不同的是，如果有其他锁阻止该锁被建立，则调用进程进入睡眠状态，等待该锁释放。一旦这个调用开始了等待，就只有在能够进行加锁或者收到信号时才会返回

需要注意的是，F_GETLK 用于测试是否可以加锁，在 F_GETLK 测试可以加锁之后，F_SETLK 和 F_SETLKW 就会企图建立一把锁，但是这两者之间并不是一个原子操作，也就是说，在 F_SETLK 或者 F_SETLKW 还没有成功加锁之前，另外一个进程就有可能已经插进来加上了一把锁。而且，F_SETLKW 有可能导致程序长时间睡眠。还有，程序对某个文件拥有的各种锁会在相应的文件描述符被关闭时自动清除，程序运行结束后，其所加的各种锁也会自动清除。

fcntl() 既可以用于劝告锁，也可以用于强制锁，在默认情况下，它用于劝告锁。如果它用于强制锁，当进程对某个文件进行了读或写这样的系统调用时，系统则会检查该文件的锁的 O_NONBLOCK 标识，该标识是文件状态标识的一种，如果设置文件状态标识的时候设置了 O_NONBLOCK，则该进程会出错返回；否则，该进程被阻塞。cmd 参数的值 F_SETFL 可以用于设置文件状态标识。

此外，系统调用 fcntl() 还可以用于租借锁，此时采用的函数原型如下：

	       int fcntl(int fd, int cmd, long arg);
            

与租借锁相关的 cmd 参数的取值有两种：F_SETLEASE 和 F_GETLEASE。其含义如下所示：

• F_SETLEASE：根据下面所描述的 arg 参数指定的值来建立或者删除租约：
  • F_RDLCK：设置读租约。当文件被另一个进程以写的方式打开时，拥有该租约的当前进程会收到通知
  • F_WRLCK：设置写租约。当文件被另一个进程以读或者写的方式打开时，拥有该租约的当前进程会收到通知
  • F_UNLCK：删除以前建立的租约
• F_GETLEASE：表明调用进程拥有文件上哪种类型的锁，这需要通过返回值来确定，返回值有三种：F_RDLCK、F_WRLCK和F_UNLCK，分别表明调用进程对文件拥有读租借、写租借或者根本没有租借

某个进程可能会对文件执行其他一些系统调用（比如 OPEN() 或者 TRUNCATE()），如果这些系统调用与该文件上由 F_SETLEASE 所设置的租借锁相冲突，内核就会阻塞这个系统调用；同时，内核会给拥有这个租借锁的进程发信号，告知此事。拥有此租借锁的进程会对该信号进行反馈，它可能会删除这个租借锁，也可能会减短这个租借锁的租约，从而可以使得该文件可以被其他进程所访问。如果拥有租借锁的进程不能在给定时间内完成上述操作，那么系统会强制帮它完成。通过 F_SETLEASE 命令将 arg 参数指定为 F_UNLCK 就可以删除这个租借锁。不管对该租借锁减短租约或者干脆删除的操作是进程自愿的还是内核强迫的，只要被阻塞的系统调用还没有被发出该调用的进程解除阻塞，那么系统就会允许这个系统调用执行。即使被阻塞的系统调用因为某些原因被解除阻塞，但是上面对租借锁减短租约或者删除这个过程还是会执行的。

需要注意的是，租借锁也只能对整个文件生效，而无法实现记录级的加锁。

文件锁的使用样例

为了使读者更深入理解本文中介绍的内容，下面我们给出了一个例子来详细介绍文件锁的具体用法。这个例子可以用来检测所使用的文件是否支持强制锁，其源代码如下所示：

            # cat -n mandlock.c
            1  #include <errno.h>
            2  #include <stdio.h>
            3  #include <fcntl.h>
            4  #include <sys/wait.h>
            5  #include <sys/stat.h>
            6
            7  int lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
            8  {
            9          struct flock    lock;
            10
            11          lock.l_type = type;     /* F_RDLCK, F_WRLCK, F_UNLCK */
            12          lock.l_start = offset;  /* byte offset, relative to l_whence */
            13          lock.l_whence = whence; /* SEEK_SET, SEEK_CUR, SEEK_END */
            14          lock.l_len = len;       /* #bytes (0 means to EOF) */
            15
            16          return( fcntl(fd, cmd, &lock) );
            17  }
            18
            19  #define read_lock(fd, offset, whence, len) \
            20                          lock_reg(fd, F_SETLK, F_RDLCK, offset, whence, len)
            21  #define write_lock(fd, offset, whence, len) \
            22                          lock_reg(fd, F_SETLK, F_WRLCK, offset, whence, len)
            23
            24  #define err_sys(x) { perror(x); exit(1); }
            25
            26  int main(int argc, char *argv[])
            27  {
            28      int             fd, val;
            29      pid_t           pid;
            30      char            buf[5];
            31      struct stat     statbuf;
            32      if (argc != 2) {
            33          fprintf(stderr, "usage: %s filename\n", argv[0]);
            34          exit(1);
            35      }
            36      if ((fd = open(argv[1], O_RDWR | O_CREAT | O_TRUNC )) < 0)
            37          err_sys("open error");
            38      if (write(fd, "hello world", 11) != 11)
            39          err_sys("write error");
            40
            41      /* turn on set-group-ID and turn off group-execute */
            42      if (fstat(fd, &statbuf) < 0)
            43          err_sys("fstat error");
            44      if (fchmod(fd, (statbuf.st_mode & ~S_IXGRP) | S_ISGID) < 0)
            45          err_sys("fchmod error");
            46
            47      sleep(2);
            48
            49      if ((pid = fork()) < 0) {
            50          err_sys("fork error");
            51      } else if (pid > 0) {   /* parent */
            52          /* write lock entire file */
            53          if (write_lock(fd, 0, SEEK_SET, 0) < 0)
            54              err_sys("write_lock error");
            55
            56          sleep(20);      /* wait for child to set lock and read data */
            57
            58          if (waitpid(pid, NULL, 0) < 0)
            59              err_sys("waitpid error");
            60
            61      } else {            /* child */
            62          sleep(10);      /* wait for parent to set lock */
            63
            64          if ( (val = fcntl(fd, F_GETFL, 0)) < 0)
            65                  err_sys("fcntl F_GETFL error");
            66
            67          val |= O_NONBLOCK;           /* turn on O_NONBLOCK flag */
            68
            69          if (fcntl(fd, F_SETFL, val) < 0)
            70                  err_sys("fcntl F_SETFL error");
            71
            72         /* first let's see what error we get if region is locked */
            73         if (read_lock(fd, 0, SEEK_SET, 0) != -1)    /* no wait */
            74             err_sys("child: read_lock succeeded");
            75
            76 printf("read_lock of already-locked region returns %d: %s\n", errno, strerror(errno));
            77
            78         /* now try to read the mandatory locked file */
            79         if (lseek(fd, 0, SEEK_SET) == -1)
            80             err_sys("lseek error");
            81         if (read(fd, buf, 5) < 0)
            82             printf("read failed (mandatory locking works)\n");
            83         else
            84             printf("read OK (no mandatory locking), buf = %5.5s\n", buf);
            85      }
            86      exit(0);
            87  }
            88
            

样例代码中所采用的技术在前文中大都已经介绍过了，其基本思想是在首先在父进程中对文件加上写锁；然后在子进程中将文件描述符设置为非阻塞模式（第 69 行），然后对文件加读锁，并尝试读取该文件中的内容。如果系统支持强制锁，则子进程中的 read() 系统调用（代码中的第 81 行）会立即返回 EAGAIN；否则，等父进程完成写文件操作之后，子进程中的 read() 系统调用就会返回父进程刚刚写入的前 5 个字节的数据。代码中的几个 sleep() 是为了协调父进程与子进程之间的同步而使用的。

该程序在测试系统的执行结果如下所示：

# mount | grep mnt
            /dev/sdb7 on /mnt type ext3 (rw,mand)
            /dev/sdb6 on /tmp/mnt type ext3 (rw)
            # ./mandlock /mnt/testfile
            read_lock of already-locked region returns 11: Resource temporarily unavailable
            read failed (mandatory locking works)
            # ./mandlock /tmp/mnt/testfile
            read_lock of already-locked region returns 11: Resource temporarily unavailable
            read OK (no mandatory locking), buf = hello
            

我们可以看到，/dev/sdb7 使用 –o mand 选项挂载到了 /mnt 目录中，而 /dev/sdb6 则么有使用这个选项挂载到了 /tmp/mnt 目录中。由于在程序中我们完成了对测试文件 SGID 和同组可执行位的设置（第 44 行），因此 /mnt/testfile 可以支持强制锁，而 /tmp/mnt/testfile 则不能。这也正是为什么前者的 read() 系统调用会失败返回而后者则可以成功读取到 hello 的原因。

总结

Linux 的文件锁在以共享索引节点共享文件的情况下设计的，文件锁的实现可以使得不同用户同时读写同一文件的并发问题得以解决。本文描述了 Linux 中各类文件锁的概念，使用场景，内核中描述文件锁的数据结构以及与文件锁密切相关的系统调用等内容，至于与文件锁相关的索引节点数据结构，以及在对文件进行加锁时遇到的死锁问题等其他知识，这里没有做详尽介绍，感兴趣的读者可以自行参考内核源代码。

本文的目的是想帮助读者理清 Linux 2.6中文件锁的概念以及 Linux 2.6 都提供了何种数据结构以及关键的系统调用来实现文件锁，从而可以帮助读者更好地使用文件锁来解决多个进程读取同一个文件的互斥问题。

参考资料

• Linux 内核源代码中包含了文件锁的具体实现，本文中引用的内核代码来自于 Linux  2.6.23 版本的内核。
  
  
• File Locking in Linux 2.5一文中介绍了在 Linux 2.5 开发时对文件锁的一些设计考虑。
  
  
• The Single UNIX® Specification, Version 3 规范中对 fcntl 系统调用进行了详细的规定。
  
  
• Linux 内核情景分析(上)一书的文件系统一章详细描述了 Linux 内核对各种不同类锁的管理和控制，讲述了 Linux 文件锁的关键的数据结构及其实现，以及文件锁对其他的文件模式和操作的影响
  
  
• 在 Understanding the Linux Kernel(3^rd Edition) 中，有关于 Linux 中不同种类文件锁详细的实现过程
  
  
• 更多的关于 Linux 开发的资源，参见 developerWorks 上 Linux 专区。

mandlock.c