Linux中POSIX文件锁的实现
来源：互联网 发布：mac苹果商店打不开 编辑：程序博客网 时间：2024/05/21 09:15
我试图通过个人的理解方式讲解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将文件锁的区域按照从左到右排序，提高了锁的访问效率。
0 0
- Linux中POSIX文件锁的实现
- linux内核posix文件锁实现
- POSIX 线程取消点的 Linux 实现
- POSIX 线程取消点的 Linux 实现
- POSIX 线程取消点的 Linux 实现
- POSIX 线程取消点的 Linux 实现
- 利用POSIX文件函数部分实现linux中的cp功能
- POSIX Clock 的实现
- POSIX 线程取消点的 Linux 实现(zz)
- POCO中Event同步对象的POSIX实现
- Linux/Unix 编程中 POSIX 函数的线程安全问题
- Linux/Unix 编程中 POSIX 函数的线程安全问题
- Linux/Unix 编程中 POSIX 函数的线程安全问题
- linux的线程(posix thread)
- Linux的Posix aio API
- linux中实现文件路径的查找
- linux中rar文件解压缩的实现
- Linux Posix Timer实现代码分析
- C# where用法
- ActionBar-PullToRefresh 学习之导入到Eclipse
- vijos1327 回文词
- API Sanity Checker在Ubuntu中的使用
- 由数字式子生成对应的二叉树
- Linux中POSIX文件锁的实现
- 一些图像变换1402，旋转、缩放、二值化、边界涂黑等
- hdu1501——Zipper
- ehcache memcache redis三大缓存男高音
- 子类父类调用的执行顺序及代码块的执行顺序
- HDU 1518 Square（深搜）
- myeclipse使用及其快捷键
- poj1004
- C语言学习之typedef
