linux 1.0 内核注解 linux/fs/locks.c

taozhijiangscu

/********************************************
*Created By: Prometheus
*Date        : 2009-5-19      
********************************************/
/*
*  linux/fs/locks.c
*
*  Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
*  Doug Evans, 92Aug07, dje@sspiff.uucp.
*
* FIXME: two things aren't handled yet:
*    - deadlock detection/avoidance (of dubious merit, but since it's in
*      the definition, I guess it should be provided eventually)
*    - mandatory locks (requires lots of changes elsewhere)
*
*  Edited by Kai Petzke, wpp@marie.physik.tu-berlin.de
*/
#include
#include
#include
#include
#include
#include
            //2G大小
#define OFFSET_MAX    ((off_t)0x7fffffff)    /* FIXME: move elsewhere? */
static int copy_flock(struct file *filp, struct file_lock *fl, struct flock *l,
                      unsigned int fd);
static int conflict(struct file_lock *caller_fl, struct file_lock *sys_fl);
static int overlap(struct file_lock *fl1, struct file_lock *fl2);
static int lock_it(struct file *filp, struct file_lock *caller, unsigned int fd);
static struct file_lock *alloc_lock(struct file_lock **pos, struct file_lock *fl,
                                    unsigned int fd);
static void free_lock(struct file_lock **fl);
static struct file_lock file_lock_table[NR_FILE_LOCKS];    /*64个锁*/
static struct file_lock *file_lock_free_list;
/*
* Called at boot time to initialize the lock table ...
*/
void fcntl_init_locks(void)
{
    struct file_lock *fl;
    /*这里是在启动的时候初始化中被调用的，首先将前面的63个锁构成
     *链表的结构*/
    for (fl = &file_lock_table[0]; fl fl_next = fl + 1;
        fl->fl_owner = NULL;
    }   
   
    /*最后的一个锁的初始化操作*/
    file_lock_table[NR_FILE_LOCKS - 1].fl_next = NULL;
    file_lock_table[NR_FILE_LOCKS - 1].fl_owner = NULL;
   
    /*空闲锁的链表*/
    file_lock_free_list = &file_lock_table[0];
}
// struct flock {
//            short l_type;   //F_RDLCK(共享锁) 、F_WRLCK(排他锁)和 F_UNLCK(删除之前建立的锁)
//            short l_whence; //SEEK_SET、SEEK_CUR 或 SEEK_END
//            off_t l_start;
//            off_t l_len;    //如果是正数，锁的范围就是start~start+len-1，如果是0就表示从start到文件的结尾
//            pid_t l_pid;    // /* PID of process blocking our lock(F_GETLK only) */
// };
//用于 F_GETLK,一般是用于在加锁之前的检测而不是实际的进行加锁操作
//看 l 指向的一个锁结构是否同已经被加的锁相冲突,如果是
//冲突就将原先的所复制到 l 指向的空间中
int fcntl_getlk(unsigned int fd, struct flock *l)
{
    int error;
    struct flock flock;
    struct file *filp;
    struct file_lock *fl,file_lock;
    if (fd >= NR_OPEN || !(filp = current->filp[fd]))
        return -EBADF;
    error = verify_area(VERIFY_WRITE,l, sizeof(*l));
    if (error)
        return error;
        
    /*数据传输方向flock f_inode->i_flock; fl != NULL; fl = fl->fl_next) {
        //这里表示冲突，就将冲突的锁的信息复制到参数指向的空间中进行返回
        if (conflict(&file_lock, fl)) {
            flock.l_pid = fl->fl_owner->pid;
            flock.l_start = fl->fl_start;
            flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :        //这里的0体现出来了吧
                fl->fl_end - fl->fl_start + 1;
            flock.l_whence = fl->fl_whence;
            flock.l_type = fl->fl_type;
            memcpy_tofs(l, &flock, sizeof(flock));
            return 0;
        }
    }
    /*这里没有冲突了，然后将锁类型设置为F_UNLCK并复制返回
     *表示原先的锁的类型是可以上锁的哦*/
    flock.l_type = F_UNLCK;            
    memcpy_tofs(l, &flock, sizeof(flock));
    return 0;
}
/*
* This function implements both F_SETLK and F_SETLKW.
*/
//设置 l 指定的文件锁,前者如果设置失败就返回错误;而后者如果不能
//设置就进入睡眠等待,直到这个锁可用为止
int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
{
    int error;
    struct file *filp;
    struct file_lock *fl,file_lock;
    struct flock flock;
    /*
     * Get arguments and validate them ...
     */
    if (fd >= NR_OPEN || !(filp = current->filp[fd]))
        return -EBADF;
    error = verify_area(VERIFY_WRITE, l, sizeof(*l));
    if (error)
        return error;
    memcpy_fromfs(&flock, l, sizeof(flock));
    if (!copy_flock(filp, &file_lock, &flock, fd))
        return -EINVAL;
    switch (file_lock.fl_type) {        //锁的类型和访问方式进行匹配
    case F_RDLCK :
        if (!(filp->f_mode & 1))
            return -EBADF;
        break;
    case F_WRLCK :
        if (!(filp->f_mode & 2))
            return -EBADF;
        break;
    case F_SHLCK :
        if (!(filp->f_mode & 3))
            return -EBADF;
        file_lock.fl_type = F_RDLCK;
        break;
    case F_EXLCK :
        if (!(filp->f_mode & 3))
            return -EBADF;
        file_lock.fl_type = F_WRLCK;
        break;
    case F_UNLCK :
        break;
    }
      /*
       * Scan for a conflicting lock ...
       */
  
    if (file_lock.fl_type != F_UNLCK)
    {
repeat:
        for (fl = filp->f_inode->i_flock; fl != NULL; fl = fl->fl_next)
        {
            if (!conflict(&file_lock, fl))
                continue;
            /*
             * File is locked by another process. If this is
             * F_SETLKW wait for the lock to be released.
             * FIXME: We need to check for deadlocks here.
             */
            //这里表示锁有冲突，就需要根据锁的类型来看看是否等待了
            if (cmd == F_SETLKW)
            {
                if (current->signal & ~current->blocked)
                    return -ERESTARTSYS;
                interruptible_sleep_on(&fl->fl_wait);
                if (current->signal & ~current->blocked)
                    return -ERESTARTSYS;
                goto repeat;
            }
            return -EAGAIN;
          }
      }
    /*
     * Lock doesn't conflict with any other lock ...
     */
    return lock_it(filp, &file_lock, fd);
}   
/*
* This function is called when the file is closed.
*/
void fcntl_remove_locks(struct task_struct *task, struct file *filp,
                        unsigned int fd)
{
    struct file_lock *fl;
    struct file_lock **before;
    /* Find first lock owned by caller ... */
    before = &filp->f_inode->i_flock;
    //这里需要看看C语言的短路求解了，这里的目的就是要找到
    //对应的进程的指定的文件的锁结构
    while ((fl = *before) && (task != fl->fl_owner || fd != fl->fl_fd))
        before = &fl->fl_next;
    /* The list is sorted by owner and fd ... */
    //对这个进程的特定文件的所有锁进行释放
    while ((fl = *before) && task == fl->fl_owner && fd == fl->fl_fd)
        free_lock(before);
}
/*
* Verify a "struct flock" and copy it to a "struct file_lock" ...
* Result is a boolean indicating success.
*/
//将l类型的锁复制到fl中，并使得当前进程获得fl锁
static int copy_flock(struct file *filp, struct file_lock *fl, struct flock *l,
                      unsigned int fd)
{
    off_t start;
    //开头进行了很多的检测操作
    if (!filp->f_inode)    /* just in case */
        return 0;
    if (!S_ISREG(filp->f_inode->i_mode))
        return 0;
    if (l->l_type != F_UNLCK && l->l_type != F_RDLCK && l->l_type != F_WRLCK
     && l->l_type != F_SHLCK && l->l_type != F_EXLCK)
        return 0;
    switch (l->l_whence) {
    case 0 /*SEEK_SET*/ : start = 0; break;
    case 1 /*SEEK_CUR*/ : start = filp->f_pos; break;
    case 2 /*SEEK_END*/ : start = filp->f_inode->i_size; break;
    default : return 0;
    }
    if ((start += l->l_start) l_len fl_type = l->l_type;
    fl->fl_start = start;    /* we record the absolute position */
    fl->fl_whence = 0;    /* FIXME: do we record {l_start} as passed? */
    if (l->l_len == 0 || (fl->fl_end = start + l->l_len - 1) fl_end = OFFSET_MAX;    //len=0
    fl->fl_owner = current;
    fl->fl_fd = fd;
    fl->fl_wait = NULL;        /* just for cleanliness */
    return 1;
}
/*
* Determine if lock {sys_fl} blocks lock {caller_fl} ...
*/
static int conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
{
    //同一个锁结构
    if (   caller_fl->fl_owner == sys_fl->fl_owner
            && caller_fl->fl_fd == sys_fl->fl_fd)
        return 0;
    if (!overlap(caller_fl, sys_fl))
        return 0;
    switch (caller_fl->fl_type) {
    case F_RDLCK :
        return sys_fl->fl_type != F_RDLCK;    //如果后者也是读锁，这里是0表示冲突
    case F_WRLCK :
        return 1;    /* overlapping region not owned by caller */
    }
    return 0;    /* shouldn't get here, but just in case */
}
//检测两个锁的锁区域是否有重叠
static int overlap(struct file_lock *fl1, struct file_lock *fl2)
{
    //这个很容易把人弄晕的，反过来看
    // !(fl1->fl_endfl_start || fl2->fl_endfl_start)，呵呵
    return fl1->fl_end >= fl2->fl_start && fl2->fl_end >= fl1->fl_start;
}
/*
* Add a lock to a file ...
* Result is 0 for success or -ENOLCK.
*
* We merge adjacent locks whenever possible.
*
* WARNING: We assume the lock doesn't conflict with any other lock.
*/
  
/*
* Rewritten by Kai Petzke:
* We sort the lock list first by owner, then by the starting address.
*
* To make freeing a lock much faster, we keep a pointer to the lock before the
* actual one. But the real gain of the new coding was, that lock_it() and
* unlock_it() became one function.
*
* To all purists: Yes, I use a few goto's. Just pass on to the next function.
*/
//这里是实际的加锁函数，比较复杂的
static int lock_it(struct file *filp, struct file_lock *caller, unsigned int fd)
{
    struct file_lock *fl;
    struct file_lock *left = 0;
    struct file_lock *right = 0;
    struct file_lock **before;
    int added = 0;
    /*
     * Find the first old lock with the same owner as the new lock.
     */
    //一样的，找到指定进程的指定文件的锁结构链表
    before = &filp->f_inode->i_flock;
    while ((fl = *before) &&
        (caller->fl_owner != fl->fl_owner ||
         caller->fl_fd != fl->fl_fd))
        before = &fl->fl_next;
    /*
     * Look up all locks of this owner.
     */
    while (   (fl = *before)
               && caller->fl_owner == fl->fl_owner
               && caller->fl_fd == fl->fl_fd) {
        /*
         * Detect adjacent or overlapping regions (if same lock type)
         */
        //进行相同的锁类型的操作，主要的就是进行重叠区域的操作，并更具
        //需要创建新的锁结构
        //这里感觉比较困难的就是一个锁可能横跨原来的多个锁等～～
        if (caller->fl_type == fl->fl_type)
        {
            //注意的是caller是确定的，而fl是在循环中不断扫描更新的
            if (fl->fl_end fl_start - 1)
                goto next_lock;
            /*
             * If the next lock in the list has entirely bigger
             * addresses than the new one, insert the lock here.
             */
            //这里已经扫的超过来caller的结尾了
            if (fl->fl_start > caller->fl_end + 1)
                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 > caller->fl_start)
                fl->fl_start = caller->fl_start;
            else
                caller->fl_start = fl->fl_start;
            if (fl->fl_end fl_end)
                fl->fl_end = caller->fl_end;
            else
                caller->fl_end = fl->fl_end;
            //这里before(fl)的空间都被更新了，原先的before锁结构可以被释放了
            //使用更大的caller来代替了，注意的是这里是同一个锁类型，使用最大的
            //空间就可以了
            if (added) {    //区域合并过了
                free_lock(before);
                continue;
            }
            caller = fl;
            added = 1;        
            goto next_lock;
        }
        /*
         * Processing for different lock types is a bit more complex.
         */
        //运行到这里肯定是不同类型的锁结构了
        if (fl->fl_end fl_start)
            goto next_lock;
        if (fl->fl_start > caller->fl_end)
            break;
        //执行到这里就表示两个不同类型的锁有重叠的地方来，麻烦了～
        //至少欣慰的是在调用这个函数之前就进行了检测，锁是不冲突的，可以分割
        if (caller->fl_type == F_UNLCK)
            added = 1;
        if (fl->fl_start fl_start)
            left = fl;
        /*
         * If the next lock in the list has a higher end address than
         * the new one, insert the new one here.
         */
        //这里caller已经完全被处理了，可以跳出循环了
        if (fl->fl_end > caller->fl_end) {
            right = fl;
            break;
        }
        if (fl->fl_start >= caller->fl_start) {
            /*
             * The new lock completely replaces an old one (This may
             * happen several times).
             */
            if (added) {
                free_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 migth satisfy his needs.
             */
            wake_up(&fl->fl_wait);
            fl->fl_start = caller->fl_start;
            fl->fl_end   = caller->fl_end;
            fl->fl_type  = caller->fl_type;
            caller = fl;
            added = 1;
        }
        /*
         * Go on to next lock.
         */
next_lock:
        before = &(*before)->fl_next;
    }
   
    //看来added是标记需不需要分配新的锁哈
    // 分配新锁对各种类型的锁都是可能需要的(F_UNLCK除外)
    if (! added) {
        if (caller->fl_type == F_UNLCK)    //can't be like this
            return -EINVAL;
        if (! (caller = alloc_lock(before, caller, fd)))
            return -ENOLCK;
    }
   
    //到这里,caller部分已经被解决来，剩下的零碎的东西需要处理了
    if (right) {
        if (left == right) {        // ??
            /*
             * The new lock breaks the old one in two pieces, so we
             * have to allocate one more lock (in this case, even
             * F_UNLCK may fail!).
             */
            if (! (left = alloc_lock(before, right, fd))) {
                if (! added)
                    free_lock(before);
                return -ENOLCK;
            }
        }
        right->fl_start = caller->fl_end + 1;
    }
    if (left)
        left->fl_end = caller->fl_start - 1;
    return 0;
}
/*
* File_lock() inserts a lock at the position pos of the linked list.
*/
//取用一个新的所,并将这个所插入到指定的 pos 位置
//注意下面两个函数的关于指针的指针的使用!
//pos参数的确有位置信息，很巧妙
static struct file_lock *alloc_lock(struct file_lock **pos,
                    struct file_lock *fl,
                                    unsigned int     fd)
{
    struct file_lock *tmp;
    tmp = file_lock_free_list;
    if (tmp == NULL)
        return NULL;            /* no available entry */
    if (tmp->fl_owner != NULL)
        panic("alloc_lock: broken free list\n");
    /* remove from free list */
    file_lock_free_list = tmp->fl_next;
    *tmp = *fl;
    tmp->fl_next = *pos;    /* insert into file's list */
    *pos = tmp;
    tmp->fl_owner = current;    /* FIXME: needed? */
    tmp->fl_fd = fd;        /* FIXME: needed? */
    tmp->fl_wait = NULL;
    return tmp;
}
/*
* Add a lock to the free list ...
*/
static void free_lock(struct file_lock **fl_p)
{
    struct file_lock *fl;
    fl = *fl_p;
    if (fl->fl_owner == NULL)    /* sanity check */
        panic("free_lock: broken lock list\n");
    *fl_p = (*fl_p)->fl_next;
    //被释放了，已经是空闲的文件锁结构了
    fl->fl_next = file_lock_free_list;    /* add to free list */
    file_lock_free_list = fl;
    fl->fl_owner = NULL;            /* for sanity checks */
    wake_up(&fl->fl_wait);
}
文档地址:http://blogimg.chinaunix.net/blog/upfile2/090519193321.pdf


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u3/90306/showart_1933066.html