我试图通过个人的理解方式讲解Linux文件锁的实现，使用的内核版本是3.13.0。
POSIX文件锁简介
先简单说下什么是文件锁。
Linux文件锁有两种：协同锁（有些成为建议锁）和强制锁。Linux读写文件时不会对协同锁做校验，只会对强制锁做验证。我只想看Linux内核如何同步多个进程同步读写，因此不考虑协同锁。
对于强制锁，按读写属性分，有读锁和写锁，或者解释为共享锁和排斥锁。很明显，因为多个进程可以同时读取同一区域的文件，而只有一个进程对文件某一区域写才是安全的。Linux对文件锁的处理
先不看加锁相关的代码，先看看Linux读取文件时对锁的处理。提一下，本人在阅读代码时发现，跟踪某个调用时总是容易发散，或者因为逻辑过于复杂导致阅读很难进行，因此这里说代码逻辑的时候，紧跟目标，简化逻辑，以帮助理解为主。
相关数据结构file_lock
介绍代码逻辑之前，先看下Linux使用的文件锁的数据结构file_lock:
struct file_lock {
struct file_lock*fl_next; /* singly linked list forthis inode */
struct hlist_nodefl_link; /* node in global lists */
struct list_headfl_block; /* circular list of blockedprocesses */
fl_owner_t <strong><span style="color:#ff0000;">fl_owner</span></strong>;
unsigned int <strong><span style="color:#ff0000;">fl_flags</span></strong>;
unsigned char <strong><span style="color:#ff0000;">fl_type</span></strong>;
unsigned int fl_pid;
int fl_link_cpu; /* what cpu's list is this on? */
struct pid *fl_nspid;
wait_queue_head_t fl_wait;
struct file *fl_file;
loff_t <strong><span style="color:#ff0000;">fl_start</span></strong>;
loff_t <strong><span style="color:#ff0000;">fl_end</span></strong>;
struct fasync_struct* fl_fasync; /* for lease breaknotifications */
/* for lease breaks: */
unsigned longfl_break_time;
unsigned longfl_downgrade_time;
const structfile_lock_operations *fl_ops; /*Callbacks for filesystems */
const structlock_manager_operations *fl_lmops; /*Callbacks for lockmanagers */
union {
structnfs_lock_info nfs_fl;
structnfs4_lock_info nfs4_fl;
struct {
struct list_headlink; /* link in AFS vnode'spending_locks list */
int state; /* state of grant or error if -ve */
} afs;
} fl_u;
};
这里使用的锁的类型是posix，用到的主要成员包括以下几个：
fl_owner: 当前任务打开文件链表，文件锁属于打开的文件，初始化为current->files；
fl_file: 与该锁关联的文件；
fl_flags：锁的标记位，它的枚举值包括：#define FL_POSIX 1
#define FL_FLOCK 2
#define FL_ACCESS 8 /* not trying to lock,just looking */
#define FL_EXISTS 16 /* when unlocking, test forexistence */
#define FL_LEASE 32 /* lease held on this file*/
#define FL_CLOSE 64 /* unlock on close */
#define FL_SLEEP 128 /* A blocking lock */
在这里，使用的默认值是FL_POSIX | FL_ACCESS，如果本次读取操作是阻塞的，还会加上FL_SLEEP。
fl_type: 锁的类型，比如读、写等，在sys_read中，当然是读，即F_RDLCK；
fl_start：加锁的起始位置；
fl_end: 加锁的结束位置，与fl_start一起表示本次操作的文件区间。
Linux锁冲突检测
对锁的数据结构有个大致了解，现在开始看相关的系统处理。
读文件对应的系统调用为read，在内核中是sys_read，在fs/read_write.c中定义：
SYSCALL_DEFINE3(read,unsigned int, fd, char __user *, buf, size_t,count)
该调用做一些基本的参数校验动作后调用vfs_read。在这里，vfs_read首先对参数做校验，然后校验用户空间内存，接下来就是需要讨论的，对文件锁的验证：rw_verify_area。
rw_verify_area有四个参数：
int read_write：读（READ），写（WRITE）；
struct file *file：系统记录文件读写操作的信息，与文件描述符关联；
const loff_t *ppos：读写的文件当前位置；
size_t count：读写的字节数。
下面是rw_verify_area的函数实现。
</pre><pre name="code" class="cpp">int rw_verify_area(int read_write, struct file *file, const loff_t *ppos, size_t count)
{
struct inode *inode;
loff_t pos;
int retval = -EINVAL;
inode = file_inode(file); // 获取文件的inode数据。file是打开文件后才会产生的记录文件读写
// 信息等的数据结构。而inode是记录文件本身的信息，比如文件创建
// 时间、文件大小等信息，详细可以参考
// http://blog.csdn.net/panda19881/article/details/7799499
// (讲解struct inode)和
// http://www.cnblogs.com/QJohnson/archive/2011/06/24/2089414.html
// （讲解inode 与file的关系）。
if (unlikely((ssize_t) count < 0)) // 校验参数：读取的字节数不能是负数
return retval;
pos = *ppos;
if (unlikely(pos < 0)) { // 读取的位置
if (!unsigned_offsets(file))
return retval;
if (count >= -pos) /* both values are in 0..LLONG_MAX */ <==> count >= pos + INT_MAX
return -EOVERFLOW;
} else if (unlikely((loff_t) (pos + count) < 0)) {
if (!unsigned_offsets(file))
return retval;
}
if (unlikely(inode->i_flock && mandatory_lock(inode))) { // 这里判断是否需要校验强制锁，
// 不管怎么处理的，直接跳过去。
retval = <strong><span style="color:#ff0000;">locks_mandatory_area</span></strong>( // 看名字，就是这里了
read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
inode, file, pos, count);
if (retval < 0)
return retval;
}
retval = security_file_permission(file, // 这个是做安全相关验证的，不管它
read_write == READ ? MAY_READ : MAY_WRITE);
if (retval)
return retval;
return count > MAX_RW_COUNT ? MAX_RW_COUNT : count;
}
这里面与文件锁相关的关键点在这里： locks_mandatory_area ，可惜它也是对核心的一个封装，看下实现。
int locks_mandatory_area(int read_write, struct inode *inode,
struct file *filp, loff_t offset,
size_t count)
{
struct file_lock fl; // file_lock是内核中用来记录文件锁相关信息的，它的主要成员会在下面做初始化，
// 因此看看下面的几行就可以对它有个基本了解了。
int error;
locks_init_lock(&fl); // 最基本的数据结构初始化，忽略它先。
fl.fl_owner = current->files; // 文件锁的owner，这里是指当前task的文件files列表
// (fl_owner: struct files_struct *)。
fl.fl_pid = current->tgid; // tgid是线程相对于进程的线程号，thread group id
fl.fl_file = filp; // 文件（struct file *）
fl.fl_flags = FL_POSIX | FL_ACCESS; // 文件锁标志（POSIX锁，FL_ACCESS表示仅仅锁校验）
if (filp && !(filp->f_flags & O_NONBLOCK)) // 判断是否允许阻塞操作
fl.fl_flags |= FL_SLEEP; // 如果可以阻塞，加上FL_SLEEP参数
fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK; // 锁类型，读还是写
fl.fl_start = offset; // 锁的起始位置
fl.fl_end = offset + count - 1; // 锁的结束为止，与fl_start一起表示一个文件区域
for (;;) { // 这里做一个循环，一直等到锁冲突接触或者出现异常
error = <strong><span style="color:#ff0000;">__posix_lock_file</span></strong>(inode, &fl, NULL); // 这里对文件锁做校验
if (error != FILE_LOCK_DEFERRED)
break;
error = wait_event_interruptible(fl.fl_wait, !fl.fl_next); // 等待其他进程解锁
if (!error) {
/*
* If we've been sleeping someone might have
* changed the permissions behind our back.
*/
if (__mandatory_lock(inode)) // Linux的注释很清楚，就是这个循环过程中，可能有人
// 修改文件属性，导致不需要加锁
continue;
}
locks_delete_block(&fl); // 把锁从阻塞队列中移除
break;
}
return error;
}
锁冲突检测核心逻辑
紧跟步伐，看看这个函数怎么做的：__posix_lock_file，函数太长，先看一部分（代码都是一点点看的^_^）。
static int __posix_lock_file(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
{
struct file_lock *fl;
struct file_lock *new_fl = NULL;
struct file_lock *new_fl2 = NULL;
struct file_lock *left = NULL;
struct file_lock *right = NULL;
struct file_lock **before;
int error;
bool added = false;
/*
* We may need two file_lock structures for this operation,
* so we get them in advance to avoid races.
*
* In some cases we can be sure, that no new locks will be needed
*/
if (!(request->fl_flags & FL_ACCESS) &&
(request->fl_type != F_UNLCK ||
request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
new_fl = locks_alloc_lock();
new_fl2 = locks_alloc_lock();
} // 这里弄了两个新的锁，先不管他，待会儿哪里用到了再看（让流程简化）
spin_lock(&inode->i_lock);
/*
* New lock request. Walk all POSIX locks and look for conflicts. If
* there are any, either return error or put the request on the
* blocker's list of waiters and the global blocked_hash.
*/
if (request->fl_type != F_UNLCK) { // 从读函数过来的，fl_type是F_RDLCK。
for_each_lock(inode, before) { // 这里是对inode相关的锁做一个遍历
// （inode是什么？它记录了一个文件的信
// 息，不是文件打开时创建的，文件在，
// 它就在。打开一次文件，就会有一个
// struct file 与它关联，当然加一次锁，
// 也会记录到这个结构上来）
fl = *before;
if (!IS_POSIX(fl)) // 我们看的都是POSIX锁。
continue;
if (!<strong><span style="color:#ff0000;">posix_locks_conflict</span></strong>(request, fl)) // 检测冲突，待会儿重点看下它
continue;
if (conflock) // 这个参数是传过来的，是NULL，不管它
__locks_copy_lock(conflock, fl);
error = -EAGAIN;
if (!(request->fl_flags & FL_SLEEP)) // 冲突了，也不等，直接退出
goto out;
/*
* Deadlock detection and insertion into the blocked
* locks list must be done while holding the same lock!
*/
error = -EDEADLK;
spin_lock(&blocked_lock_lock); // 这里检测死锁
if (likely(!<strong><span style="color:#ff0000;">posix_locks_deadlock</span></strong>(request, fl))) { // 这是核心，检测死锁的。
error = FILE_LOCK_DEFERRED;
__locks_insert_block(fl, request);
}
spin_unlock(&blocked_lock_lock);
goto out;
}
}
/* If we're just looking for a conflict, we're done. */
error = 0;
if (request->fl_flags & FL_ACCESS) // 到这里，说明inode中的锁全部校验完了，
// 没有跟我们的锁有冲突的，而且我们也就是
// 检测是否有锁冲突，不加锁也不解锁
// (FL_ACCESS)。read读取校验锁的部分结
// 束了，所以这段代码暂时看到这里！
goto out;
// …….. // 到此为止，简化逻辑
这段代码看下来，对检测锁冲突的流程有了了解，它是拿读的区域跟当前inode（即文件）的所有锁做检测，看看哪个有冲突，所有都没有冲突，那就可以返回成功。否则，如果不是阻塞操作，也退出。允许阻塞时，做一个死锁检测（死锁检测是干啥的？）。
现在看里面两个重点：posix_locks_conflict和posix_locks_deadlock。检测两个锁之间是否存在冲突
锁冲突检测：这个函数看起来简单，就几行代码，其实也真的好简单。
/* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
* checking before calling the locks_conflict().
*/
static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
{
/* POSIX locks owned by the same process do not conflict with
* each other.
*/
if (!IS_POSIX(sys_fl) || <strong><span style="color:#ff0000;">posix_same_owner</span></strong>(caller_fl, sys_fl)) // 1. 只检测POSIX锁，这个逻辑跟上面的重复了
// 2. 看看两个锁的owner是否相同，是同一个
// owner也不算冲突
return (0);
/* Check whether they overlap */
if (!<strong><span style="color:#ff0000;">locks_overlap</span></strong>(caller_fl, sys_fl)) // 判断两个锁的区域是否有重叠
return 0;
return (<strong><span style="color:#ff0000;">locks_conflict</span></strong>(caller_fl, sys_fl)); // 两个都不能是写锁，写锁就是冲突
}
抛开锁的类型（只考虑POSIX锁），判断两个锁有冲突条件是：
锁的owner不同；
锁的区域有重叠；
其中一个是写锁（排斥锁）。
file_lock有个成员变量是fl_owner，但是检测两个锁的owner是否相同不是仅仅判断下这两个变量相同：
static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
{
if (fl1->fl_lmops && fl1->fl_lmops->lm_compare_owner)
return fl2->fl_lmops == fl1->fl_lmops &&
fl1->fl_lmops->lm_compare_owner(fl1, fl2); // 他还支持自定义比较两把锁
// owner的函数，好吧，我也脱离主干分岔了
return fl1->fl_owner == fl2->fl_owner; // 在这里，其实就是检测下owner变量是否相等。
}
再看看怎么检测区域重叠，就像检测一条直线上的两个线段是否有重叠：
/* Check if two locks overlap each other.
*/
static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
{
return ((fl1->fl_end >= fl2->fl_start) &&
(fl2->fl_end >= fl1->fl_start));
}
简单的啥也不用说。
死锁检测
锁冲突检测完毕，看看死锁检测posix_locks_deadlock。
/* Must be called with the blocked_lock_lock held! */
static int posix_locks_deadlock(struct file_lock *caller_fl,
struct file_lock *block_fl)
// 两个参数：caller_fl，我们检测的那个锁；block_fl，有冲突的那个锁
// 如果这个函数返回1，就认为有死锁
{
int i = 0;
while ((block_fl = <strong><span style="color:#ff0000;">what_owner_is_waiting_for</span></strong>(block_fl))) { // 这个函数从阻塞<span style="font-family: Arial, Helvetica, sans-serif;">列表中找跟block_fl同</span><span style="font-family: Arial, Helvetica, sans-serif;"> </span>
<span style="font-family: Arial, Helvetica, sans-serif;"></span><pre name="code" class="cpp"> //<span style="font-family: Arial, Helvetica, sans-serif;"> 一个owner的锁，待会儿看它的实现</span>
if (i++ > MAX_DEADLK_ITERATIONS) // 如果同一个owner下等待的锁达到了上限，就<span style="font-family: Arial, Helvetica, sans-serif;">认为是死锁</span><pre name="code" class="cpp"> //<span style="font-family: Arial, Helvetica, sans-serif;">（MAX_DEADLK_ITERATIONS，我的代码中是10）</span>
return 0;
if (posix_same_owner(caller_fl, block_fl)) // 如果有个锁跟我们要检测的锁属<span style="font-family: Arial, Helvetica, sans-serif;">于同一个owner，认为</span>
<span style="font-family: Arial, Helvetica, sans-serif;"> // </span><span style="font-family: Arial, Helvetica, sans-serif;"> 是死锁</span>
return 1;
}
return 0; // 检测完了，没有相同owner的，没有死锁
}
再回过头来看__posix_lock_file函数，它的作用是检测文件关联的所有锁，看看是否有冲突，就是owner不同、区域有重叠且是个写锁。
Linux对文件读写锁/解锁的实现
如果仅仅是读取或者写入操作，那锁的校验也就到此结束了。不过现在还不知道锁是怎么添加的，怎么解锁的。
Linux对提供了一个fcntl函数来操作POSIX文件锁。
fcntl的定义如下：
int fcntl(intfildes, int cmd, ...);
fildes是文件描述符；
cmd表示本次fcntl操作的命令；
后面是命令的参数，如果是文件锁，对应的cmd是F_SETLK(加读写锁、解锁等)，后面的参数是struct flock：
shortl_type 文件锁的类型： F_RDLCK, F_WRLCK, F_UNLCK
short l_whence 从哪里开始（文件起始位置、当前位置还是末尾）
off_tl_start 锁的起始相对偏移量
off_tl_len 大小，如果是0表示到文件末尾
pid_tl_pid 当前拥有这把锁的进程ID，在F_GETLK时返回。
fcntl对应的系统调用函数是(fs/fcntl.c)：
SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
{
struct fd f = fdget_raw(fd); // 根据文件描述符获取文件相关信息
long err = -EBADF;
if (!f.file)
goto out;
if (unlikely(f.file->f_mode & FMODE_PATH)) { // 验证参数有效性
if (!check_fcntl_cmd(cmd))
goto out1;
}
err = security_file_fcntl(f.file, cmd, arg); // 安全相关
if (!err)
err = do_fcntl(fd, cmd, arg, f.file); // 真正的处理系统调用
out1:
fdput(f);
out:
return err;
}
do_fcntl的定义如下：
static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
struct file *filp)
{
long err = -EINVAL;
switch (cmd) {
….. // 此处省略N个字节
case F_GETLK: // 获取锁信息
err = fcntl_getlk(filp, (struct flock __user *) arg);
break;
case F_SETLK:
case F_SETLKW: // 加锁
err = <strong><span style="color:#ff0000;">fcntl_setlk</span></strong>(fd, filp, cmd, (struct flock __user *) arg);
break;
……. // 再省略N个字节
}
return err;
}
看看加锁的fcntl_setlk函数：
int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
struct flock __user *l)
{
struct file_lock *file_lock = locks_alloc_lock(); // 申请一个file_lock
struct flock flock;
struct inode *inode;
struct file *f;
int error;
if (file_lock == NULL)
return -ENOLCK;
/*
* This might block, so we do it before checking the inode.
*/
error = -EFAULT;
if (copy_from_user(&flock, l, sizeof(flock))) // 把数据从用户空间复制到内核空间
goto out;
inode = file_inode(filp); // 获取文件的inode结构
/* Don't allow mandatory locks on files that may be memory mapped
* and shared.
*/
if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) { // 校验加锁的条件
error = -EAGAIN;
goto out;
}
again: // 这里有一个循环
error = <strong><span style="color:#ff0000;">flock_to_posix_lock</span></strong>(filp, file_lock, &flock); // 根据传入的flock信息转换为内核数据结构
// file_lock（按照flock提供的文件区域信
// 息，填充到file_lock中）
if (error)
goto out;
if (cmd == F_SETLKW) { // 最后一个W是Wait的意思，就是允许等待
file_lock->fl_flags |= FL_SLEEP;
}
error = -EBADF;
switch (flock.l_type) { // 验证锁类型与当前打开文件的模式是否匹配
case F_RDLCK:
if (!(filp->f_mode & FMODE_READ)) // 加了读锁，但是文件打开模式不包含读取
goto out;
break;
case F_WRLCK: // 写锁，校验与读锁类似
if (!(filp->f_mode & FMODE_WRITE))
goto out;
break;
case F_UNLCK: // 解锁啥都不用干了，就是解锁
break;
default:
error = -EINVAL;
goto out;
}
error = <strong><span style="color:#ff0000;">do_lock_file_wait</span></strong>(filp, cmd, file_lock); // 看名字猜，这里就是去加锁的函数
// 如果在这个过程中，这个文件被关闭了，文件描述符重新分配
// 给了其他文件，就得回退，加了的锁再解锁
/*
* Attempt to detect a close/fcntl race and recover by
* releasing the lock that was just acquired.
*/
/*
* we need that spin_lock here - it prevents reordering between
* update of inode->i_flock and check for it done in close().
* rcu_read_lock() wouldn't do.
*/
spin_lock(¤t->files->file_lock);
f = fcheck(fd); // 获取描述符fd对应的struct file 结构（文件打开时会创建对应的struct file）
spin_unlock(¤t->files->file_lock);
if (!error && f != filp && flock.l_type != F_UNLCK) { // !error: 加锁函数执行成
// 功，表示加锁或者解锁操作成功；f != filep：描述符对
// 应的打开文件已经变了，需要做回退操作；
// flock.l_type != F_UNLCK：如果原来就是解锁了，那
// 就不用回退，解锁无需回退
flock.l_type = F_UNLCK; // 加锁变成解锁
goto again; // 执行回退操作
}
out:
locks_free_lock(file_lock);
return error;
}
flock_to_posix_lock这个函数比较简单，是把用户层的参数flock转换为内核层数据结构file_lock，既然简单，就简单看下吧。
static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
struct flock *l)
{
off_t start, end;
switch (l->l_whence) { // 文件偏移量从哪里计算
case SEEK_SET: // 从文件起始处
start = 0;
break;
case SEEK_CUR: // 文件当前位置
start = filp->f_pos; // struct file记录了当前操作的文件位置
break;
case SEEK_END: // 文件结尾
start = i_size_read(file_inode(filp)); // 这个就是文件大小
break;
default:
return -EINVAL;
}
/* POSIX-1996 leaves the case l->l_len < 0 undefined;
POSIX-2001 defines it. */
start += l->l_start; // 计算加锁的文件起始位置：文件便宜位置+相对位置
if (start < 0)
return -EINVAL;
fl->fl_end = OFFSET_MAX; // 下面几行计算加锁区域的结束位置
if (l->l_len > 0) { // 加锁的长度大于0，没什么说的
end = start + l->l_len - 1;
fl->fl_end = end;
} else if (l->l_len < 0) { // 如过给的是负数，区域结尾就是当前计算的
// 起始位置start-1，起始位置改成起始位置
// 加上这个负的长度
end = start - 1;
fl->fl_end = end;
start += l->l_len;
if (start < 0)
return -EINVAL;
} // 这里没有说长度是0的处理，其实就用的默
// 认值OFFSET_MAX，可以一直到文件末尾
fl->fl_start = start; /* we record the absolute position */
if (fl->fl_end < fl->fl_start)
return -EOVERFLOW;
fl->fl_owner = current->files; // 这几个参数跟前面说的计算方法是一样的
fl->fl_pid = current->tgid;
fl->fl_file = filp;
fl->fl_flags = FL_POSIX;
fl->fl_ops = NULL;
fl->fl_lmops = NULL;
return assign_type(fl, l->l_type); // 校验l_type是否合法：读锁、写锁和解锁之一
}
回到重点do_lock_file_wait函数，其实这个函数也没啥重点的，只是它调用了核心函数。
static int do_lock_file_wait(struct file *filp, unsigned int cmd,
struct file_lock *fl)
{
int error;
error = security_file_lock(filp, fl->fl_type); // 安全检测，略过
if (error)
return error;
for (;;) { // 循环尝试加锁或解锁
error = <strong><span style="color:#ff0000;">vfs_lock_file</span></strong>(filp, cmd, fl, NULL); // 加锁核心函数
if (error != FILE_LOCK_DEFERRED)
break;
error = wait_event_interruptible(fl->fl_wait, !fl->fl_next); // 需要等待就等一下
if (!error)
continue;
locks_delete_block(fl);
break;
}
return error;
}
vfs_lock_file相当简单，也只是一个函数的封装：
int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)
{
if (filp->f_op->lock) // 文件系统如果提供了自己的锁，就用自己的（ext2文件系统没有提供这个文件锁函数，所以不看它）
return filp->f_op->lock(filp, cmd, fl);
else
return <strong><span style="color:#ff0000;">posix_lock_file</span></strong>(filp, fl, conf); // 系统提供的标准POSIX文件锁
}
posix_lock_file真的也不想说什么，它就一句话：
return __posix_lock_file(file_inode(filp),fl, conflock);
加锁解锁的核心逻辑
__posix_lock_file，前面也提到了。它分为两部分，第一部分的功能是检测文件锁是否有冲突，在上面已经介绍过了；第二部分是真正的加锁，或者解锁的，主要的还是处理与当前的锁处理冲突，比如合并、分解，或者删除。
只看第二部分，看代码前提前说一点，文件锁都是按区域来的，对一个区域，只能有一种类型的锁，多个文件锁，是按照区域从小到大来排序的，而且不会有交叉重叠。好，来看代码吧，只有下半部分。/*
* Find the first old lock with the same owner as the new lock.
*/
before = &inode->i_flock; // struct file_lock *，与这个文件关联的文件锁列表
// 下面的合并或者拆解操作都是针对同一个owner的锁操作的
/* First skip locks owned by other processes. */
while ((fl = *before) && (!IS_POSIX(fl) || // 找到第一个同一个owner的锁
!posix_same_owner(request, fl))) {
before = &fl->fl_next;
}
/* Process locks with this owner. */
while ((fl = *before) && posix_same_owner(request, fl)) {
/* Detect adjacent or overlapping regions (if same lock type)
*/
if (request->fl_type == fl->fl_type) { // 锁的类型是相同的，都是读锁，或都是写锁，不会是解锁
// 这里先找到有区域重叠的锁
// 不过要注意的是，不能用end+1,只能用start -1
// 来比较，因为end可能是OFFSET_MAX，这时候
// end+1就溢出了
if (fl->fl_end < request->fl_start - 1) // 新锁在fl的右边
goto next_lock;
/* If the next lock in the list has entirely bigger
* addresses than the new one, insert the lock here.
*/
if (fl->fl_start - 1 > request->fl_end) // 新锁在左边
break;
/* If we come here, the new and old lock are of the
* same type and adjacent or overlapping. Make one
* lock yielding from the lower start address of both
* locks to the higher end address.
*/
// 有重叠或者相同，把它们合并起来
if (fl->fl_start > request->fl_start) // 找左边界
fl->fl_start = request->fl_start;
else
request->fl_start = fl->fl_start;
if (fl->fl_end < request->fl_end) // 找右边界
fl->fl_end = request->fl_end;
else
request->fl_end = fl->fl_end;
if (added) { // 这个added是说是不是第一次合并，如果不是的话，得删掉一把
// 锁，第一次不用删
locks_delete_lock(before); // 删除后fl自动移动到了下一个锁
continue;
}
request = fl;
added = true;
}
else { // 处理不同类型的锁，如果有重叠的话，新锁的区域应该覆盖旧锁
/* Processing for different lock types is a bit
* more complex.
*/
if (fl->fl_end < request->fl_start) // 没有重叠，不过这里比较的不是start – 1，而是start，
// 为什么？因为相同类型的锁，边界相邻，需要做合并
goto next_lock;
if (fl->fl_start > request->fl_end) // 没有重叠
break;
if (request->fl_type == F_UNLCK)
added = true; // added = true将锁删掉
if (fl->fl_start < request->fl_start)// 当前锁的左边界在request左边界的左边
left = fl; // 记录下left
/* If the next lock in the list has a higher end
* address than the new one, insert the new one here.
*/
if (fl->fl_end > request->fl_end) { // 当前的锁右边界在request右边界的右边
right = fl; // 记录下right
break; // 找到了比request还要靠右的，那就不用找了，后面的肯定跟
// request没有重叠的
}
if (fl->fl_start >= request->fl_start) { // 这把锁的左边界在request左边界的右边，结合上面
// 那个分析判断，这时候fl肯定完全被request覆盖掉了
/* The new lock completely replaces an old
* one (This may happen several times).
*/
if (added) { // 如果已经添加过一把新锁或者是解锁操作
locks_delete_lock(before); // 直接删除旧锁，否则à
continue;
}
/* Replace the old lock with the new one.
* Wake up anybody waiting for the old one,
* as the change in lock type might satisfy
* their needs.
*/
locks_wake_up_blocks(fl);
fl->fl_start = request->fl_start; // 用新的锁覆盖旧的锁
fl->fl_end = request->fl_end;
fl->fl_type = request->fl_type;
locks_release_private(fl);
locks_copy_private(fl, request);
request = fl;
added = true;
}
}
/* Go on to next lock.
*/
next_lock:
before = &fl->fl_next;
}
// 这个循环做完了，可能会得到这样的结果：<span style="font-family: Arial, Helvetica, sans-serif;"> </span>
// 1. 与相同类型的锁合并了，或者合并了一部分；
// 2. 替换掉了不同类型的锁；
// 3. 找到了一个这个锁左边的一把锁（指左边界）；
// 4. 找到了一个这个锁右边的一把锁（指右边界）
/*
* The above code only modifies existing locks in case of merging or
* replacing. If new lock(s) need to be inserted all modifications are
* done below this, so it's safe yet to bail out.
*/
error = -ENOLCK; /* "no luck" */
if (right && left == right && !new_fl2) // 如果找到了一个可以覆盖request的锁，但是没有创建一个新锁
// new_fl2的话，直接退出。什么时候会创建new_fl2?在这个函数最前面有一个判断，new_fl2与
// new_fl同时创建，条件是：1. 本次不是仅仅检测锁状态，2. 不是解锁，起始位置不是0，结束
// 为止不是OFFSET_MAX（综合起来看第二个条件，就是说如果解锁时，解的是从0到最大值，就是
// 整个文件上加的锁肯定会解开，那就不可能会创建新的锁），那就会创建这两个锁
goto out;
error = 0;
if (!added) { // 这个标志打上了，说明request没有被因为锁区域冲突处理过
if (request->fl_type == F_UNLCK) { // 解锁操作
if (request->fl_flags & FL_EXISTS) // FL_EXISTS这个标志位是说，如果执行解锁操作时，仅仅查看锁是否存在
error = -ENOENT; // 返回不存在（没有冲突的锁）
goto out;
}
// request锁在所有锁的缝隙中，与其他锁没有任何区域重叠，或者就是第一把锁，就把这把锁加进去
if (!new_fl) {
error = -ENOLCK;
goto out;
}
locks_copy_lock(new_fl, request);
locks_insert_lock(before, new_fl);
new_fl = NULL;
}
// 下面处理类型不同，但是有重叠区域的锁
// right是指右边界在request右边的锁
// left是指左边界在request左边的锁
if (right) { // 如果找到了request右边的那把锁
if (left == right) { // 且左边的锁跟右边的是同一把，就是这把旧锁的区域把request的区域覆盖了，
// 那就把这把锁拆开，左边一个，中间一个request，右边一个
/* The new lock breaks the old one in two pieces,
* so we have to use the second new lock.
*/
left = new_fl2; // 左边保留
new_fl2 = NULL;
locks_copy_lock(left, right);
locks_insert_lock(before, left);
}
right->fl_start = request->fl_end + 1; // 调整右边锁的区域，左边锁的区域下面会调整
locks_wake_up_blocks(right);
}
if (left) { // 找到了request左边的那把锁，但是没有覆盖掉request（否则right也等于
// left，在上面的逻辑就处理掉了）；或者是找到了覆盖掉request的那把锁，
// 现在处理左半边那把锁
left->fl_end = request->fl_start - 1;
locks_wake_up_blocks(left);
}
out:
spin_unlock(&inode->i_lock);
/*
* Free any unused locks.
*/
if (new_fl)
locks_free_lock(new_fl);
if (new_fl2)
locks_free_lock(new_fl2);
return error;
}
加锁的核心部分已经完成了，代码函数虽然有点长，但是逻辑还是很清晰，目的就是检测锁冲突，新锁覆盖旧锁。
总结
POSIX文件锁是为了保证多个程序同时访问同一个文件时数据的完整性。Linux在每次文件读写和加锁时都会检测是否有锁冲突，每次加锁或解锁，都会更新相应区域的锁为新锁类型，当然，解锁是直接把该区域的锁信息删除。另外，Linux将文件锁的区域按照从左到右排序，提高了锁的访问效率。
扫一扫
2014
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
