locks: break delegations on any attribute modification

NFSv4 uses leases to guarantee that clients can cache metadata as well
as data.

Cc: Mikulas Patocka <mikulas@artax.karlin.mff.cuni.cz>
Cc: David Howells <dhowells@redhat.com>
Cc: Tyler Hicks <tyhicks@canonical.com>
Cc: Dustin Kirkland <dustin.kirkland@gazzang.com>
Acked-by: Jeff Layton <jlayton@redhat.com>
Signed-off-by: J. Bruce Fields <bfields@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 1b8490e2fbdeae0c62799a30cfd2c1848874d169..0f3820121e02effe1c0dcf257cafadad02fc7469 100644 (file)
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -216,7 +216,7 @@ static int handle_create(const char *nodename, umode_t mode, kuid_t uid,
                newattrs.ia_gid = gid;
                newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID;
                mutex_lock(&dentry->d_inode->i_mutex);
-               notify_change(dentry, &newattrs);
+               notify_change(dentry, &newattrs, NULL);
                mutex_unlock(&dentry->d_inode->i_mutex);
 
                /* mark as kernel-created inode */
@@ -322,7 +322,7 @@ static int handle_remove(const char *nodename, struct device *dev)
                        newattrs.ia_valid =
                                ATTR_UID|ATTR_GID|ATTR_MODE;
                        mutex_lock(&dentry->d_inode->i_mutex);
-                       notify_change(dentry, &newattrs);
+                       notify_change(dentry, &newattrs, NULL);
                        mutex_unlock(&dentry->d_inode->i_mutex);
                        err = vfs_unlink(parent.dentry->d_inode, dentry, NULL);
                        if (!err || err == -ENOENT)

diff --git a/fs/attr.c b/fs/attr.c
index 1449adb14ef6a468b3d97865499df941a2c28312..267968d946739a2f3c17a20b4ffb5776e21ece75 100644 (file)
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -167,7 +167,27 @@ void setattr_copy(struct inode *inode, const struct iattr *attr)
 }
 EXPORT_SYMBOL(setattr_copy);
 
-int notify_change(struct dentry * dentry, struct iattr * attr)
+/**
+ * notify_change - modify attributes of a filesytem object
+ * @dentry:    object affected
+ * @iattr:     new attributes
+ * @delegated_inode: returns inode, if the inode is delegated
+ *
+ * The caller must hold the i_mutex on the affected object.
+ *
+ * If notify_change discovers a delegation in need of breaking,
+ * it will return -EWOULDBLOCK and return a reference to the inode in
+ * delegated_inode.  The caller should then break the delegation and
+ * retry.  Because breaking a delegation may take a long time, the
+ * caller should drop the i_mutex before doing so.
+ *
+ * Alternatively, a caller may pass NULL for delegated_inode.  This may
+ * be appropriate for callers that expect the underlying filesystem not
+ * to be NFS exported.  Also, passing NULL is fine for callers holding
+ * the file open for write, as there can be no conflicting delegation in
+ * that case.
+ */
+int notify_change(struct dentry * dentry, struct iattr * attr, struct inode **delegated_inode)
 {
        struct inode *inode = dentry->d_inode;
        umode_t mode = inode->i_mode;
@@ -241,6 +261,9 @@ int notify_change(struct dentry * dentry, struct iattr * attr)
                return 0;
 
        error = security_inode_setattr(dentry, attr);
+       if (error)
+               return error;
+       error = try_break_deleg(inode, delegated_inode);
        if (error)
                return error;
 

diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 43eb5592cdea83c83df854a489edea79d076cfda..5088a418ac4d2c1a0644b636f1aecf0b9a8edd00 100644 (file)
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -449,14 +449,14 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
                _debug("discard tail %llx", oi_size);
                newattrs.ia_valid = ATTR_SIZE;
                newattrs.ia_size = oi_size & PAGE_MASK;
-               ret = notify_change(object->backer, &newattrs);
+               ret = notify_change(object->backer, &newattrs, NULL);
                if (ret < 0)
                        goto truncate_failed;
        }
 
        newattrs.ia_valid = ATTR_SIZE;
        newattrs.ia_size = ni_size;
-       ret = notify_change(object->backer, &newattrs);
+       ret = notify_change(object->backer, &newattrs, NULL);
 
 truncate_failed:
        mutex_unlock(&object->backer->d_inode->i_mutex);

diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 1c628f0230417cdcb3cb2732a1ba632526fe2ad5..c36c4482447159c219a4d4f56506087229ebb276 100644 (file)
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -882,7 +882,7 @@ int ecryptfs_truncate(struct dentry *dentry, loff_t new_length)
                struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
 
                mutex_lock(&lower_dentry->d_inode->i_mutex);
-               rc = notify_change(lower_dentry, &lower_ia);
+               rc = notify_change(lower_dentry, &lower_ia, NULL);
                mutex_unlock(&lower_dentry->d_inode->i_mutex);
        }
        return rc;
@@ -983,7 +983,7 @@ static int ecryptfs_setattr(struct dentry *dentry, struct iattr *ia)
                lower_ia.ia_valid &= ~ATTR_MODE;
 
        mutex_lock(&lower_dentry->d_inode->i_mutex);
-       rc = notify_change(lower_dentry, &lower_ia);
+       rc = notify_change(lower_dentry, &lower_ia, NULL);
        mutex_unlock(&lower_dentry->d_inode->i_mutex);
 out:
        fsstack_copy_attr_all(inode, lower_inode);

diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index 345713d2f8f31ee4590af09147457b8839081840..1b39afdd86fd8dbe543c476829e6919325005459 100644 (file)
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -407,7 +407,7 @@ again:
                        /*printk("HPFS: truncating file before delete.\n");*/
                        newattrs.ia_size = 0;
                        newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
-                       err = notify_change(dentry, &newattrs);
+                       err = notify_change(dentry, &newattrs, NULL);
                        put_write_access(inode);
                        if (!err)
                                goto again;

diff --git a/fs/inode.c b/fs/inode.c
index ce48c359ce9e336aee71e7654425a7bdf659d536..4bcdad3c93612920e809da639ff933e5af08d0f7 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -1603,7 +1603,11 @@ static int __remove_suid(struct dentry *dentry, int kill)
        struct iattr newattrs;
 
        newattrs.ia_valid = ATTR_FORCE | kill;
-       return notify_change(dentry, &newattrs);
+       /*
+        * Note we call this on write, so notify_change will not
+        * encounter any conflicting delegations:
+        */
+       return notify_change(dentry, &newattrs, NULL);
 }
 
 int file_remove_suid(struct file *file)

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 27ba21b5f383866c8e0444833455ed54c91ea485..94b5f5d2bfedd94be68e7879a8cf8b40d0e3cde3 100644 (file)
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -427,7 +427,7 @@ nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
                        goto out_nfserr;
                fh_lock(fhp);
 
-               host_err = notify_change(dentry, iap);
+               host_err = notify_change(dentry, iap, NULL);
                err = nfserrno(host_err);
                fh_unlock(fhp);
        }
@@ -988,7 +988,11 @@ static void kill_suid(struct dentry *dentry)
        ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
 
        mutex_lock(&dentry->d_inode->i_mutex);
-       notify_change(dentry, &ia);
+       /*
+        * Note we call this on write, so notify_change will not
+        * encounter any conflicting delegations:
+        */
+       notify_change(dentry, &ia, NULL);
        mutex_unlock(&dentry->d_inode->i_mutex);
 }
 

diff --git a/fs/open.c b/fs/open.c
index fffbed40dbe9e24dc6129878cf65527e241d4d48..4b3e1edf2fe4d917e69e56b3e268e32f2ae7301a 100644 (file)
--- a/fs/open.c
+++ b/fs/open.c
@@ -57,7 +57,8 @@ int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
                newattrs.ia_valid |= ret | ATTR_FORCE;
 
        mutex_lock(&dentry->d_inode->i_mutex);
-       ret = notify_change(dentry, &newattrs);
+       /* Note any delegations or leases have already been broken: */
+       ret = notify_change(dentry, &newattrs, NULL);
        mutex_unlock(&dentry->d_inode->i_mutex);
        return ret;
 }
@@ -464,21 +465,28 @@ out:
 static int chmod_common(struct path *path, umode_t mode)
 {
        struct inode *inode = path->dentry->d_inode;
+       struct inode *delegated_inode = NULL;
        struct iattr newattrs;
        int error;
 
        error = mnt_want_write(path->mnt);
        if (error)
                return error;
+retry_deleg:
        mutex_lock(&inode->i_mutex);
        error = security_path_chmod(path, mode);
        if (error)
                goto out_unlock;
        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
-       error = notify_change(path->dentry, &newattrs);
+       error = notify_change(path->dentry, &newattrs, &delegated_inode);
 out_unlock:
        mutex_unlock(&inode->i_mutex);
+       if (delegated_inode) {
+               error = break_deleg_wait(&delegated_inode);
+               if (!error)
+                       goto retry_deleg;
+       }
        mnt_drop_write(path->mnt);
        return error;
 }
@@ -522,6 +530,7 @@ SYSCALL_DEFINE2(chmod, const char __user *, filename, umode_t, mode)
 static int chown_common(struct path *path, uid_t user, gid_t group)
 {
        struct inode *inode = path->dentry->d_inode;
+       struct inode *delegated_inode = NULL;
        int error;
        struct iattr newattrs;
        kuid_t uid;
@@ -546,12 +555,17 @@ static int chown_common(struct path *path, uid_t user, gid_t group)
        if (!S_ISDIR(inode->i_mode))
                newattrs.ia_valid |=
                        ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
+retry_deleg:
        mutex_lock(&inode->i_mutex);
        error = security_path_chown(path, uid, gid);
        if (!error)
-               error = notify_change(path->dentry, &newattrs);
+               error = notify_change(path->dentry, &newattrs, &delegated_inode);
        mutex_unlock(&inode->i_mutex);
-
+       if (delegated_inode) {
+               error = break_deleg_wait(&delegated_inode);
+               if (!error)
+                       goto retry_deleg;
+       }
        return error;
 }
 

diff --git a/fs/utimes.c b/fs/utimes.c
index f4fb7eca10e832f5b9c4405092627b94f4a163dc..aa138d64560a6a3c2133bc70d57e367cc8c1476d 100644 (file)
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -53,6 +53,7 @@ static int utimes_common(struct path *path, struct timespec *times)
        int error;
        struct iattr newattrs;
        struct inode *inode = path->dentry->d_inode;
+       struct inode *delegated_inode = NULL;
 
        error = mnt_want_write(path->mnt);
        if (error)
@@ -101,9 +102,15 @@ static int utimes_common(struct path *path, struct timespec *times)
                                goto mnt_drop_write_and_out;
                }
        }
+retry_deleg:
        mutex_lock(&inode->i_mutex);
-       error = notify_change(path->dentry, &newattrs);
+       error = notify_change(path->dentry, &newattrs, &delegated_inode);
        mutex_unlock(&inode->i_mutex);
+       if (delegated_inode) {
+               error = break_deleg_wait(&delegated_inode);
+               if (!error)
+                       goto retry_deleg;
+       }
 
 mnt_drop_write_and_out:
        mnt_drop_write(path->mnt);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 6e36e7118ec12ce44c44a348e0efed2bb07894ee..ab2a0ca82dc57fd34381debb4d63b802a5ca0235 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2278,7 +2278,7 @@ extern void emergency_remount(void);
 #ifdef CONFIG_BLOCK
 extern sector_t bmap(struct inode *, sector_t);
 #endif
-extern int notify_change(struct dentry *, struct iattr *);
+extern int notify_change(struct dentry *, struct iattr *, struct inode **);
 extern int inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int);