Cleanup macros for distinguishing mandatory locks

The combination of S_ISGID bit set and S_IXGRP bit unset is used to mark the
inode as "mandatory lockable" and there's a macro for this check called
MANDATORY_LOCK(inode).  However, fs/locks.c and some filesystems still perform
the explicit i_mode checking.  Besides, Andrew pointed out, that this macro is
buggy itself, as it dereferences the inode arg twice.

Convert this macro into static inline function and switch its users to it,
making the code shorter and more readable.

The __mandatory_lock() helper is to be used in places where the IS_MANDLOCK()
for superblock is already known to be true.

Signed-off-by: Pavel Emelyanov <xemul@openvz.org>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Cc: "J. Bruce Fields" <bfields@fieldses.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Cc: Steven Whitehouse <swhiteho@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/locks.c b/fs/locks.c
index 43dbc7f566fa97f829ae4e1448aa4a8fd5ba64df..9a3fe0d8285b178403aa76ce2d34358c7ec6c9d6 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1119,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;
                }
 
@@ -1761,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;
        }
@@ -1887,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;
        }
@@ -2083,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     ");

diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 3f559700788f1603a60840ce7bfc3b20e857fd48..3c028b9c6e0e8a29377749ce6fda99972e9122c3 100644 (file)
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -2044,7 +2044,7 @@ static inline int
 io_during_grace_disallowed(struct inode *inode, int flags)
 {
        return nfs4_in_grace() && (flags & (RD_STATE | WR_STATE))
-               && MANDATORY_LOCK(inode);
+               && mandatory_lock(inode);
 }
 
 /*

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 7867151ebb83b16c6c3bcd446acfead317ec282e..9152f87eea1896ca276c40cd741cd42f434c016f 100644 (file)
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -65,7 +65,7 @@
  * locks on them because there is no way to know if the accesser has
  * the lock.
  */
-#define IS_ISMNDLK(i)  (S_ISREG((i)->i_mode) && MANDATORY_LOCK(i))
+#define IS_ISMNDLK(i)  (S_ISREG((i)->i_mode) && mandatory_lock(i))
 
 /*
  * This is a cache of readahead params that help us choose the proper

diff --git a/fs/read_write.c b/fs/read_write.c
index 507ddff48a9a9e673d75d161d0fc8ad09c00faef..124693e8d3fa068d60e7f6ad82670a3577ae80fb 100644 (file)
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -205,7 +205,7 @@ int rw_verify_area(int read_write, struct file *file, loff_t *ppos, size_t count
        if (unlikely((pos < 0) || (loff_t) (pos + count) < 0))
                goto Einval;
 
-       if (unlikely(inode->i_flock && MANDATORY_LOCK(inode))) {
+       if (unlikely(inode->i_flock && mandatory_lock(inode))) {
                int retval = locks_mandatory_area(
                        read_write == READ ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE,
                        inode, file, pos, count);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 16421f662a7ad6074e107a47f8d9be92ad185064..f5075e0e73016b7b7b224f48278079b30ebccecc 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1369,12 +1369,25 @@ extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size
  * Candidates for mandatory locking have the setgid bit set
  * but no group execute bit -  an otherwise meaningless combination.
  */
-#define MANDATORY_LOCK(inode) \
-       (IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
+
+static inline int __mandatory_lock(struct inode *ino)
+{
+       return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
+}
+
+/*
+ * ... and these candidates should be on MS_MANDLOCK mounted fs,
+ * otherwise these will be advisory locks
+ */
+
+static inline int mandatory_lock(struct inode *ino)
+{
+       return IS_MANDLOCK(ino) && __mandatory_lock(ino);
+}
 
 static inline int locks_verify_locked(struct inode *inode)
 {
-       if (MANDATORY_LOCK(inode))
+       if (mandatory_lock(inode))
                return locks_mandatory_locked(inode);
        return 0;
 }
@@ -1385,7 +1398,7 @@ static inline int locks_verify_truncate(struct inode *inode,
                                    struct file *filp,
                                    loff_t size)
 {
-       if (inode->i_flock && MANDATORY_LOCK(inode))
+       if (inode->i_flock && mandatory_lock(inode))
                return locks_mandatory_area(
                        FLOCK_VERIFY_WRITE, inode, filp,
                        size < inode->i_size ? size : inode->i_size,