Cleanup macros for distinguishing mandatory locks

[net-next-2.6.git] / fs / locks.c

diff --git a/fs/locks.c b/fs/locks.c
index 50857d2d3404a821268fb787f74ee1f7335ebd98..9a3fe0d8285b178403aa76ce2d34358c7ec6c9d6 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -534,7 +534,9 @@ static void locks_insert_block(struct file_lock *blocker,
 static void locks_wake_up_blocks(struct file_lock *blocker)
 {
        while (!list_empty(&blocker->fl_block)) {
-               struct file_lock *waiter = list_entry(blocker->fl_block.next,
+               struct file_lock *waiter;
+
+               waiter = list_first_entry(&blocker->fl_block,
                                struct file_lock, fl_block);
                __locks_delete_block(waiter);
                if (waiter->fl_lmops && waiter->fl_lmops->fl_notify)
@@ -668,7 +670,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
        for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
                if (!IS_POSIX(cfl))
                        continue;
-               if (posix_locks_conflict(cfl, fl))
+               if (posix_locks_conflict(fl, cfl))
                        break;
        }
        if (cfl)
@@ -715,8 +717,7 @@ next_task:
 }
 
 /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
- * at the head of the list, but that's secret knowledge known only to
- * flock_lock_file and posix_lock_file.
+ * after any leases, but before any posix locks.
  *
  * Note that if called with an FL_EXISTS argument, the caller may determine
  * whether or not a lock was successfully freed by testing the return
@@ -733,6 +734,15 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
        lock_kernel();
        if (request->fl_flags & FL_ACCESS)
                goto find_conflict;
+
+       if (request->fl_type != F_UNLCK) {
+               error = -ENOMEM;
+               new_fl = locks_alloc_lock();
+               if (new_fl == NULL)
+                       goto out;
+               error = 0;
+       }
+
        for_each_lock(inode, before) {
                struct file_lock *fl = *before;
                if (IS_POSIX(fl))
@@ -754,10 +764,6 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
                goto out;
        }
 
-       error = -ENOMEM;
-       new_fl = locks_alloc_lock();
-       if (new_fl == NULL)
-               goto out;
        /*
         * If a higher-priority process was blocked on the old file lock,
         * give it the opportunity to lock the file.
@@ -782,7 +788,7 @@ find_conflict:
        if (request->fl_flags & FL_ACCESS)
                goto out;
        locks_copy_lock(new_fl, request);
-       locks_insert_lock(&inode->i_flock, new_fl);
+       locks_insert_lock(before, new_fl);
        new_fl = NULL;
        error = 0;
 
@@ -819,7 +825,7 @@ static int __posix_lock_file(struct inode *inode, struct file_lock *request, str
        lock_kernel();
        if (request->fl_type != F_UNLCK) {
                for_each_lock(inode, before) {
-                       struct file_lock *fl = *before;
+                       fl = *before;
                        if (!IS_POSIX(fl))
                                continue;
                        if (!posix_locks_conflict(request, fl))
@@ -1113,7 +1119,7 @@ int locks_mandatory_area(int read_write, struct inode *inode,
                         * If we've been sleeping someone might have
                         * changed the permissions behind our back.
                         */
-                       if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
+                       if (__mandatory_lock(inode))
                                continue;
                }
 
@@ -1337,6 +1343,7 @@ int fcntl_getlease(struct file *filp)
 int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
 {
        struct file_lock *fl, **before, **my_before = NULL, *lease;
+       struct file_lock *new_fl = NULL;
        struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        int error, rdlease_count = 0, wrlease_count = 0;
@@ -1363,6 +1370,11 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
                || (atomic_read(&inode->i_count) > 1)))
                goto out;
 
+       error = -ENOMEM;
+       new_fl = locks_alloc_lock();
+       if (new_fl == NULL)
+               goto out;
+
        /*
         * At this point, we know that if there is an exclusive
         * lease on this file, then we hold it on this filp
@@ -1405,18 +1417,15 @@ int generic_setlease(struct file *filp, long arg, struct file_lock **flp)
        if (!leases_enable)
                goto out;
 
-       error = -ENOMEM;
-       fl = locks_alloc_lock();
-       if (fl == NULL)
-               goto out;
-
-       locks_copy_lock(fl, lease);
+       locks_copy_lock(new_fl, lease);
+       locks_insert_lock(before, new_fl);
 
-       locks_insert_lock(before, fl);
+       *flp = new_fl;
+       return 0;
 
-       *flp = fl;
-       error = 0;
 out:
+       if (new_fl != NULL)
+               locks_free_lock(new_fl);
        return error;
 }
 EXPORT_SYMBOL(generic_setlease);
@@ -1752,9 +1761,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
        /* Don't allow mandatory locks on files that may be memory mapped
         * and shared.
         */
-       if (IS_MANDLOCK(inode) &&
-           (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
-           mapping_writably_mapped(filp->f_mapping)) {
+       if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
                error = -EAGAIN;
                goto out;
        }
@@ -1878,9 +1885,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
        /* Don't allow mandatory locks on files that may be memory mapped
         * and shared.
         */
-       if (IS_MANDLOCK(inode) &&
-           (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
-           mapping_writably_mapped(filp->f_mapping)) {
+       if (mandatory_lock(inode) && mapping_writably_mapped(filp->f_mapping)) {
                error = -EAGAIN;
                goto out;
        }
@@ -2074,9 +2079,7 @@ static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
                out += sprintf(out, "%6s %s ",
                             (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ",
                             (inode == NULL) ? "*NOINODE*" :
-                            (IS_MANDLOCK(inode) &&
-                             (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ?
-                            "MANDATORY" : "ADVISORY ");
+                            mandatory_lock(inode) ? "MANDATORY" : "ADVISORY ");
        } else if (IS_FLOCK(fl)) {
                if (fl->fl_type & LOCK_MAND) {
                        out += sprintf(out, "FLOCK  MSNFS     ");