Implement NFSv4 delegations, take 12
Subsystems (10)
cover Implement NFSv4 delegations, take 12
From: "J. Bruce Fields" <[email protected]>
Al, if you don't see any objections, could you queue this up for 3.13?
Changes since version 11:
- rebase to 3.12-rc1
- fix to lock class in single-lock case of lock_two_nondirectories
Changes since version 10:
- appended Jeff's fix for a setlease/open race (otherwise unrelated to this series, but there are some minor conficts to resolve).
Changes since version 9:
- just a rebase to 3.11-rc6
Changes since version 8:
- additional warnings in lock_two_nondirectories
- lock_two_nondirectories handles NULL second argument, simplifying vfs_rename_other
- kerneldoc comments on notify_change, vfs_link, vfs_rename, vfs_unlink, to explain delegated_inode argument.
- make clear non-support of write delegations in generic_add_lease
- rebase to 3.11-rc1
Introduction copied from previous posting:
This patch series implements read delegations, which allow NFSv4 clients to perform read opens without contacting the server, by promising to call back to clients before modifying the data, metadata, or set of links pointing to a file.
The main recent change was in response to review from Linus, who didn't want us to hang under directory i_mutex's on timeouts communicating with unresponsive clients.
So, this version of the series drops the i_mutex before waiting. The logic ends up looking something like:
acquire locks
look up inode
test for delegation; if found:
take reference on inode
release locks
wait for delegation break
drop reference on inode
retry
The initial test for a delegation happens after the lock on the delegated inode is acquired, but additional directory mutexes may have been acquired further up the call stack. I therefore add a "struct inode **" argument to any intervening functions, which we use to pass the inode back up to the caller in the case it needs to wait for the delegation to be broken.
I also allow callers to pass in NULL for the "struct inode **" argument to indicate they'd rather just fail than wait for a delegation. For example, as long as ecryptfs isn't exportable I assume they'd rather not see retry logic there that they won't use. But I may have misjudged in some of these cases.
J. Bruce Fields (12):
vfs: pull ext4's double-i_mutex-locking into common code
vfs: don't use PARENT/CHILD lock classes for non-directories
vfs: rename I_MUTEX_QUOTA now that it's not used for quotas
vfs: take i_mutex on renamed file
locks: introduce new FL_DELEG lock flag
locks: implement delegations
namei: minor vfs_unlink cleanup
locks: break delegations on unlink
locks: helper functions for delegation breaking
locks: break delegations on rename
locks: break delegations on link
locks: break delegations on any attribute modification
Jeff Layton (1):
locks: close potential race between setlease and open
Documentation/filesystems/directory-locking | 31 ++++-- drivers/base/devtmpfs.c | 6 +- fs/attr.c | 25 ++++- fs/cachefiles/interface.c | 4 +- fs/cachefiles/namei.c | 4 +- fs/ecryptfs/inode.c | 6 +- fs/ext4/ext4.h | 2 - fs/ext4/ioctl.c | 4 +- fs/ext4/move_extent.c | 40 +------- fs/hpfs/namei.c | 2 +- fs/inode.c | 42 ++++++++- fs/locks.c | 130 +++++++++++++++++++++----- fs/namei.c | 135 +++++++++++++++++++++++---- fs/nfsd/nfs4state.c | 2 +- fs/nfsd/vfs.c | 14 ++- fs/open.c | 22 ++++- fs/utimes.c | 9 +- include/linux/fs.h | 78 +++++++++++++--- ipc/mqueue.c | 2 +- 19 files changed, 428 insertions(+), 130 deletions(-)
Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 5/13 locks: introduce new FL_DELEG lock flag
In reply to a message not in the archiveFrom: "J. Bruce Fields" <[email protected]>
For now FL_DELEG is just a synonym for FL_LEASE. So this patch doesn't change behavior.
Next we'll modify break_lease to treat FL_DELEG leases differently, to account for the fact that NFSv4 delegations should be broken in more situations than Windows oplocks.
--- fs/locks.c | 2 +- fs/nfsd/nfs4state.c | 2 +- include/linux/fs.h | 1 + 3 files changed, 3 insertions(+), 2 deletions(-)
fs/locks.c +1 -1
@@ -134,7 +134,7 @@#define IS_POSIX (fl) (fl->fl_flags & FL_POSIX)#define IS_FLOCK (fl) (fl->fl_flags & FL_FLOCK) -#define IS_LEASE (fl) (fl->fl_flags & FL_LEASE) +#define IS_LEASE (fl) (fl->fl_flags & (FL_LEASE|FL_DELEG))static bool lease_breaking (struct file_lock *fl) {
fs/nfsd/nfs4state.c +1 -1
@@ -3008,7 +3008,7 @@ static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int freturn NULL ;locks_init_lock (fl); fl->fl_lmops = &nfsd_lease_mng_ops; - fl->fl_flags =FL_LEASE ; + fl->fl_flags =FL_DELEG ; fl->fl_type = flag ==NFS4_OPEN_DELEGATE_READ ?F_RDLCK :F_WRLCK ; fl->fl_end =OFFSET_MAX ; fl->fl_owner = (fl_owner_t)(dp->dl_file);
include/linux/fs.h +1 -0
@@ -888,6 +888,7 @@ static inline int file_check_writeable(struct file *filp)#define FL_POSIX 1#define FL_FLOCK 2 +#define FL_DELEG 4/* NFSv4 delegation */ #define FL_ACCESS 8/* not trying to lock, just looking */ #define FL_EXISTS 16/* when unlocking, test for existence */ #define FL_LEASE 32/* lease held on this file */
Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 6/13 locks: implement delegations
In reply to a message not in the archiveFrom: "J. Bruce Fields" <[email protected]>
Implement NFSv4 delegations at the vfs level using the new FL_DELEG lock type.
Note nfsd is the only delegation user and is only using read delegations. Warn on any attempt to set a write delegation for now. We'll come back to that case later.
--- fs/locks.c | 55 ++++++++++++++++++++++++++++++++++++++++++---------- include/linux/fs.h | 18 ++++++++++++++--- 2 files changed, 60 insertions(+), 13 deletions(-)
fs/locks.c +45 -10
@@ -1292,28 +1292,40 @@ static void time_out_leases(struct inode *inode) } } +static bool leases_conflict (struct file_lock *lease,struct file_lock *breaker) +{ +if ((breaker->fl_flags &FL_DELEG ) && (lease->fl_flags &FL_LEASE )) +return false; +return locks_conflict (breaker, lease); +} +/** * __break_lease - revoke all outstanding leases on file * @inode: the inode of the file to return -* @mode: the open mode (read or write) +* @mode: O_RDONLY: break only write leases; O_WRONLY or O_RDWR: +* break all leases +* @type: FL_LEASE: break leases and delegations; FL_DELEG: break +* only delegations * * break_lease (inlined for speed) has checked there already is at least * some kind of lock (maybe a lease) on this file. Leases are broken on * a call to open() or truncate(). This function can sleep unless you * specified %O_NONBLOCK to your open(). */ -int __break_lease (struct inode *inode,unsigned int mode) +int __break_lease (struct inode *inode,unsigned int mode,unsigned int type) {int error =0 ;struct file_lock *new_fl, *flock;struct file_lock *fl;unsigned long break_time;int i_have_this_lease =0 ; +bool lease_conflict = false;int want_write = (mode &O_ACCMODE ) !=O_RDONLY ; new_fl =lease_alloc (NULL , want_write ?F_WRLCK :F_RDLCK );if (IS_ERR (new_fl))return PTR_ERR (new_fl); + new_fl->fl_flags = type;spin_lock (&inode->i_lock);
@@ -1323,13 +1335,16 @@ int __break_lease(struct inode *inode, unsigned int mode)if ((flock ==NULL ) || !IS_LEASE (flock)) goto out; -if (!locks_conflict (flock, new_fl)) +for (fl = flock; fl &&IS_LEASE (fl); fl = fl->fl_next) { +if (leases_conflict (fl, new_fl)) { + lease_conflict = true; +if (fl->fl_owner == current->files) + i_have_this_lease =1 ; + } + } +if (!lease_conflict) goto out; -for (fl = flock; fl &&IS_LEASE (fl); fl = fl->fl_next) -if (fl->fl_owner == current->files) - i_have_this_lease =1 ; - break_time =0 ;if (lease_break_time >0 ) { break_time = jiffies + lease_break_time *HZ ;
@@ -1338,6 +1353,8 @@ int __break_lease(struct inode *inode, unsigned int mode) }for (fl = flock; fl &&IS_LEASE (fl); fl = fl->fl_next) { +if (!leases_conflict (fl, new_fl)) +continue ;if (want_write) {if (fl->fl_flags &FL_UNLOCK_PENDING )continue ;
@@ -1379,7 +1396,7 @@ restart:*/ for (flock = inode->i_flock; flock &&IS_LEASE (flock); flock = flock->fl_next) { -if (locks_conflict (new_fl, flock)) +if (leases_conflict (new_fl, flock)) goto restart; } error =0 ;
@@ -1460,9 +1477,26 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flpstruct file_lock *fl, **before, **my_before =NULL , *lease;struct dentry *dentry = filp->f_path.dentry;struct inode *inode = dentry->d_inode; +bool is_deleg = (*flp)->fl_flags &FL_DELEG ;int error; lease = *flp; +/* +* In the delegation case we need mutual exclusion with +* a number of operations that take the i_mutex. We trylock +* because delegations are an optional optimization, and if +* there's some chance of a conflict--we'd rather not +* bother, maybe that's a sign this just isn't a good file to +* hand out a delegation on. +*/ +if (is_deleg && !mutex_trylock (&inode->i_mutex)) +return -EAGAIN ; + +if (is_deleg && arg ==F_WRLCK ) { +/* Write delegations are not currently supported: */ +WARN_ON_ONCE (1 ); +return -EINVAL ; + } error = -EAGAIN ;if ((arg ==F_RDLCK ) && (atomic_read (&inode->i_writecount) >0 ))
@@ -1514,9 +1548,10 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp goto out;locks_insert_lock (before, lease); -return 0 ; - + error =0 ; out: +if (is_deleg) +mutex_unlock (&inode->i_mutex);return error; }
include/linux/fs.h +15 -3
@@ -1030,7 +1030,7 @@ extern int vfs_test_lock(struct file *, struct file_lock *);extern int vfs_lock_file (struct file *,unsigned int ,struct file_lock *,struct file_lock *);extern int vfs_cancel_lock (struct file *filp,struct file_lock *fl);extern int flock_lock_file_wait (struct file *filp,struct file_lock *fl); -extern int __break_lease (struct inode *inode,unsigned int flags); +extern int __break_lease (struct inode *inode,unsigned int flags,unsigned int type);extern void lease_get_mtime (struct inode *,struct timespec *time);extern int generic_setlease (struct file *,long ,struct file_lock **);extern int vfs_setlease (struct file *,long ,struct file_lock **);
@@ -1139,7 +1139,7 @@ static inline int flock_lock_file_wait(struct file *filp,return -ENOLCK ; } -static inline int __break_lease (struct inode *inode,unsigned int mode) +static inline int __break_lease (struct inode *inode,unsigned int mode,unsigned int type) {return 0 ; }
@@ -1962,9 +1962,17 @@ static inline int locks_verify_truncate(struct inode *inode,static inline int break_lease (struct inode *inode,unsigned int mode) {if (inode->i_flock) -return __break_lease (inode, mode); +return __break_lease (inode, mode,FL_LEASE );return 0 ; } + +static inline int break_deleg (struct inode *inode,unsigned int mode) +{ +if (inode->i_flock) +return __break_lease (inode, mode,FL_DELEG ); +return 0 ; +} +#else /* !CONFIG_FILE_LOCKING */ static inline int locks_mandatory_locked (struct inode *inode) {
@@ -2004,6 +2012,10 @@ static inline int break_lease(struct inode *inode, unsigned int mode) return 0; } +static inline int break_deleg (struct inode *inode,unsigned int mode) +{ +return 0 ; +}#endif /* CONFIG_FILE_LOCKING */ /* fs/open.c */
Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 8/13 locks: break delegations on unlink
In reply to a message not in the archiveFrom: "J. Bruce Fields" <[email protected]>
We need to break delegations on any operation that changes the set of links pointing to an inode. Start with unlink.
Such operations also hold the i_mutex on a parent directory. Breaking a delegation may require waiting for a timeout (by default 90 seconds) in the case of a unresponsive NFS client. To avoid blocking all directory operations, we therefore drop locks before waiting for the delegation. The logic then looks like:
acquire locks
...
test for delegation; if found:
take reference on inode
release locks
wait for delegation break
drop reference on inode
retry
It is possible this could never terminate. (Even if we take precautions to prevent another delegation being acquired on the same inode, we could get a different inode on each retry.) But this seems very unlikely.
The initial test for a delegation happens after the lock on the target inode is acquired, but the directory inode may have been acquired further up the call stack. We therefore add a "struct inode **" argument to any intervening functions, which we use to pass the inode back up to the caller in the case it needs a delegation synchronously broken.
--- drivers/base/devtmpfs.c | 2 +- fs/cachefiles/namei.c | 2 +- fs/ecryptfs/inode.c | 2 +- fs/namei.c | 42 +++++++++++++++++++++++++++++++++++++++--- fs/nfsd/vfs.c | 2 +- include/linux/fs.h | 2 +- ipc/mqueue.c | 2 +- 7 files changed, 45 insertions(+), 9 deletions(-)
drivers/base/devtmpfs.c +1 -1
@@ -324,7 +324,7 @@ static int handle_remove(const char *nodename, struct device *dev)mutex_lock (&dentry->d_inode->i_mutex);notify_change (dentry, &newattrs);mutex_unlock (&dentry->d_inode->i_mutex); - err =vfs_unlink (parent.dentry->d_inode, dentry); + err =vfs_unlink (parent.dentry->d_inode, dentry,NULL );if (!err || err == -ENOENT ) deleted =1 ; }
fs/cachefiles/namei.c +1 -1
@@ -294,7 +294,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,if (ret <0 ) {cachefiles_io_error (cache,"Unlink security error" ); }else { - ret =vfs_unlink (dir->d_inode, rep); + ret =vfs_unlink (dir->d_inode, rep,NULL );if (preemptive)cachefiles_mark_object_buried (cache, rep);
fs/ecryptfs/inode.c +1 -1
@@ -153,7 +153,7 @@ static int ecryptfs_do_unlink(struct inode *dir, struct dentry *dentry,dget (lower_dentry); lower_dir_dentry =lock_parent (lower_dentry); - rc =vfs_unlink (lower_dir_inode, lower_dentry); + rc =vfs_unlink (lower_dir_inode, lower_dentry,NULL );if (rc) {printk (KERN_ERR "Error in vfs_unlink; rc = [%d]\n" , rc); goto out_unlock;
fs/namei.c +39 -3
83 lines not on this page · raw message
fs/nfsd/vfs.c +1 -1
@@ -1911,7 +1911,7 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,if (host_err) goto out_put;if (type !=S_IFDIR ) - host_err =vfs_unlink (dirp, rdentry); + host_err =vfs_unlink (dirp, rdentry,NULL );else host_err =vfs_rmdir (dirp, rdentry);if (!host_err)
include/linux/fs.h +1 -1
@@ -1467,7 +1467,7 @@ extern int vfs_mknod(struct inode *, struct dentry *, umode_t, dev_t);extern int vfs_symlink (struct inode *,struct dentry *,const char *);extern int vfs_link (struct dentry *,struct inode *,struct dentry *);extern int vfs_rmdir (struct inode *,struct dentry *); -extern int vfs_unlink (struct inode *,struct dentry *); +extern int vfs_unlink (struct inode *,struct dentry *,struct inode **);extern int vfs_rename (struct inode *,struct dentry *,struct inode *,struct dentry *);/*
ipc/mqueue.c +1 -1
@@ -886,7 +886,7 @@ SYSCALL_DEFINE1(mq_unlink, const char __user *, u_name) err = -ENOENT ; }else {ihold (inode); - err =vfs_unlink (dentry->d_parent->d_inode, dentry); + err =vfs_unlink (dentry->d_parent->d_inode, dentry,NULL ); }dput (dentry);
Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 12/13 locks: break delegations on any attribute modification
In reply to a message not in the archiveFrom: "J. Bruce Fields" <[email protected]>
NFSv4 uses leases to guarantee that clients can cache metadata as well as data.
--- drivers/base/devtmpfs.c | 4 ++-- fs/attr.c | 25 ++++++++++++++++++++++++- fs/cachefiles/interface.c | 4 ++-- fs/ecryptfs/inode.c | 2 +- fs/hpfs/namei.c | 2 +- fs/inode.c | 6 +++++- fs/nfsd/vfs.c | 8 ++++++-- fs/open.c | 22 ++++++++++++++++++---- fs/utimes.c | 9 ++++++++- include/linux/fs.h | 2 +- 10 files changed, 68 insertions(+), 16 deletions(-)
drivers/base/devtmpfs.c +2 -2
@@ -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 )
fs/attr.c +24 -1
@@ -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;
@@ -243,6 +263,9 @@ int notify_change(struct dentry * dentry, struct iattr * attr) error =security_inode_setattr (dentry, attr);if (error)return error; + error =try_break_deleg (inode, delegated_inode); +if (error) +return error;if (inode->i_op->setattr) error = inode->i_op->setattr (dentry, attr);
fs/cachefiles/interface.c +2 -2
@@ -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);
fs/ecryptfs/inode.c +1 -1
@@ -992,7 +992,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);
fs/hpfs/namei.c +1 -1
@@ -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;
fs/inode.c +5 -1
@@ -1611,7 +1611,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)
fs/nfsd/vfs.c +6 -2
@@ -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); }
fs/open.c +18 -4
@@ -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; }
fs/utimes.c +8 -1
@@ -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);
include/linux/fs.h +1 -1
@@ -2273,7 +2273,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 );
Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 1/13 vfs: pull ext4's double-i_mutex-locking into common code
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
We want to do this elsewhere as well.
Also catch any attempts to use it for directories (where this ordering would conflict with ancestor-first directory ordering in lock_rename).
--- fs/ext4/ext4.h | 2 -- fs/ext4/ioctl.c | 4 ++-- fs/ext4/move_extent.c | 40 ++-------------------------------------- fs/inode.c | 36 ++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 3 +++ 5 files changed, 43 insertions(+), 42 deletions(-)
fs/ext4/ext4.h +0 -2
@@ -2734,8 +2734,6 @@ extern void ext4_double_down_write_data_sem(struct inode *first, struct inode *second);extern void ext4_double_up_write_data_sem (struct inode *orig_inode,struct inode *donor_inode); -void ext4_inode_double_lock (struct inode *inode1,struct inode *inode2); -void ext4_inode_double_unlock (struct inode *inode1,struct inode *inode2);extern int ext4_move_extents (struct file *o_filp,struct file *d_filp,__u64 start_orig,__u64 start_donor,__u64 len,__u64 *moved_len);
fs/ext4/ioctl.c +2 -2
@@ -130,7 +130,7 @@ static long swap_inode_boot_loader(struct super_block *sb,/* Protect orig inodes against a truncate and make sure, * that only 1 swap_inode_boot_loader is running. */ -ext4_inode_double_lock (inode, inode_bl); +lock_two_nondirectories (inode, inode_bl);truncate_inode_pages (&inode->i_data,0 );truncate_inode_pages (&inode_bl->i_data,0 );
@@ -205,7 +205,7 @@ static long swap_inode_boot_loader(struct super_block *sb,ext4_inode_resume_unlocked_dio (inode);ext4_inode_resume_unlocked_dio (inode_bl); -ext4_inode_double_unlock (inode, inode_bl); +unlock_two_nondirectories (inode, inode_bl);iput (inode_bl);
fs/ext4/move_extent.c +2 -38
@@ -1203,42 +1203,6 @@ mext_check_arguments(struct inode *orig_inode, }/** -* ext4_inode_double_lock - Lock i_mutex on both @inode1 and @inode2 -* -* @inode1: the inode structure -* @inode2: the inode structure -* -* Lock two inodes' i_mutex -*/ -void -ext4_inode_double_lock (struct inode *inode1,struct inode *inode2) -{ -BUG_ON (inode1 == inode2); -if (inode1 < inode2) { -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_PARENT ); -mutex_lock_nested (&inode2->i_mutex,I_MUTEX_CHILD ); - }else { -mutex_lock_nested (&inode2->i_mutex,I_MUTEX_PARENT ); -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_CHILD ); - } -} - -/** -* ext4_inode_double_unlock - Release i_mutex on both @inode1 and @inode2 -* -* @inode1: the inode that is released first -* @inode2: the inode that is released second -* -*/ - -void -ext4_inode_double_unlock (struct inode *inode1,struct inode *inode2) -{ -mutex_unlock (&inode1->i_mutex); -mutex_unlock (&inode2->i_mutex); -} - -/** * ext4_move_extents - Exchange the specified range of a file * * @o_filp: file structure of the original file
@@ -1327,7 +1291,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp,return -EINVAL ; }/* Protect orig and donor inodes against a truncate */ -ext4_inode_double_lock (orig_inode, donor_inode); +lock_two_nondirectories (orig_inode, donor_inode);/* Wait for all existing dio workers */ ext4_inode_block_unlocked_dio (orig_inode);
@@ -1535,7 +1499,7 @@ out:ext4_double_up_write_data_sem (orig_inode, donor_inode);ext4_inode_resume_unlocked_dio (orig_inode);ext4_inode_resume_unlocked_dio (donor_inode); -ext4_inode_double_unlock (orig_inode, donor_inode); +unlock_two_nondirectories (orig_inode, donor_inode);return ret; }
fs/inode.c +36 -0
@@ -951,6 +951,42 @@ void unlock_new_inode(struct inode *inode)EXPORT_SYMBOL (unlock_new_inode);/** +* lock_two_nondirectories - take two i_mutexes on non-directory objects +* @inode1: first inode to lock +* @inode2: second inode to lock +*/ +void lock_two_nondirectories (struct inode *inode1,struct inode *inode2) +{ +WARN_ON_ONCE (S_ISDIR (inode1->i_mode)); +if (inode1 == inode2 || !inode2) { +mutex_lock_nested (&inode1->i_mutex,I_MUTEX_PARENT ); +return ; + } +WARN_ON_ONCE (S_ISDIR (inode2->i_mode)); +if (inode1 < inode2) { +mutex_lock_nested (&inode1->i_mutex,I_MUTEX_PARENT ); +mutex_lock_nested (&inode2->i_mutex,I_MUTEX_CHILD ); + }else { +mutex_lock_nested (&inode2->i_mutex,I_MUTEX_PARENT ); +mutex_lock_nested (&inode1->i_mutex,I_MUTEX_CHILD ); + } +} +EXPORT_SYMBOL (lock_two_nondirectories); + +/** +* unlock_two_nondirectories - release locks from lock_two_nondirectories() +* @inode1: first inode to unlock +* @inode2: second inode to unlock +*/ +void unlock_two_nondirectories (struct inode *inode1,struct inode *inode2) +{ +mutex_unlock (&inode1->i_mutex); +if (inode2 && inode2 != inode1) +mutex_unlock (&inode2->i_mutex); +} +EXPORT_SYMBOL (unlock_two_nondirectories); + +/** * iget5_locked - obtain an inode from a mounted file system * @sb: super block of file system * @hashval: hash value (usually inode number) to get
include/linux/fs.h +3 -0
@@ -637,6 +637,9 @@ enum inode_i_mutex_lock_class I_MUTEX_QUOTA }; +void lock_two_nondirectories (struct inode *,struct inode *); +void unlock_two_nondirectories (struct inode *,struct inode *); +/* * NOTE: in a 32bit arch with a preemptable kernel and * an UP compile the i_size_read/write must be atomic
Signature · 1 line
1.7.9.5
PATCH 2/13 vfs: don't use PARENT/CHILD lock classes for non-directories
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
Reserve I_MUTEX_PARENT and I_MUTEX_CHILD for locking of actual directories.
(Also I_MUTEX_QUOTA isn't really a meaningful name for this locking class any more; fixed in a later patch.)
--- fs/inode.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
fs/inode.c +5 -5
@@ -959,16 +959,16 @@ void lock_two_nondirectories(struct inode *inode1, struct inode *inode2) {WARN_ON_ONCE (S_ISDIR (inode1->i_mode));if (inode1 == inode2 || !inode2) { -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_PARENT ); +mutex_lock (&inode1->i_mutex);return ; }WARN_ON_ONCE (S_ISDIR (inode2->i_mode));if (inode1 < inode2) { -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_PARENT ); -mutex_lock_nested (&inode2->i_mutex,I_MUTEX_CHILD ); +mutex_lock (&inode1->i_mutex); +mutex_lock_nested (&inode2->i_mutex,I_MUTEX_QUOTA ); }else { -mutex_lock_nested (&inode2->i_mutex,I_MUTEX_PARENT ); -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_CHILD ); +mutex_lock (&inode2->i_mutex); +mutex_lock_nested (&inode1->i_mutex,I_MUTEX_QUOTA ); } }EXPORT_SYMBOL (lock_two_nondirectories);
Signature · 1 line
1.7.9.5
PATCH 3/13 vfs: rename I_MUTEX_QUOTA now that it's not used for quotas
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
I_MUTEX_QUOTA is now just being used whenever we want to lock two non-directories. So the name isn't right. I_MUTEX_NONDIR2 isn't especially elegant but it's the best I could think of.
Also fix some outdated documentation.
--- fs/inode.c | 4 ++-- include/linux/fs.h | 9 ++++++--- 2 files changed, 8 insertions(+), 5 deletions(-)
fs/inode.c +2 -2
@@ -965,10 +965,10 @@ void lock_two_nondirectories(struct inode *inode1, struct inode *inode2)WARN_ON_ONCE (S_ISDIR (inode2->i_mode));if (inode1 < inode2) {mutex_lock (&inode1->i_mutex); -mutex_lock_nested (&inode2->i_mutex,I_MUTEX_QUOTA ); +mutex_lock_nested (&inode2->i_mutex,I_MUTEX_NONDIR2 ); }else {mutex_lock (&inode2->i_mutex); -mutex_lock_nested (&inode1->i_mutex,I_MUTEX_QUOTA ); +mutex_lock_nested (&inode1->i_mutex,I_MUTEX_NONDIR2 ); } }EXPORT_SYMBOL (lock_two_nondirectories);
include/linux/fs.h +6 -3
@@ -623,10 +623,13 @@ static inline int inode_unhashed(struct inode *inode)* 0: the object of the current VFS operation * 1: parent * 2: child/target -* 3: quota file +* 3: xattr +* 4: second non-directory +* The last is for certain operations (such as rename) which lock two +* non-directories at once. * * The locking order between these classes is -* parent -> child -> normal -> xattr -> quota +* parent -> child -> normal -> xattr -> second non-directory */ enum inode_i_mutex_lock_class {
@@ -634,7 +637,7 @@ enum inode_i_mutex_lock_classI_MUTEX_PARENT ,I_MUTEX_CHILD ,I_MUTEX_XATTR , - I_MUTEX_QUOTA + I_MUTEX_NONDIR2 };void lock_two_nondirectories (struct inode *,struct inode *);
Signature · 1 line
1.7.9.5
PATCH 4/13 vfs: take i_mutex on renamed file
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
A read delegation is used by NFSv4 as a guarantee that a client can perform local read opens without informing the server.
The open operation takes the last component of the pathname as an argument, thus is also a lookup operation, and giving the client the above guarantee means informing the client before we allow anything that would change the set of names pointing to the inode.
Therefore, we need to break delegations on rename, link, and unlink.
We also need to prevent new delegations from being acquired while one of these operations is in progress.
We could add some completely new locking for that purpose, but it's simpler to use the i_mutex, since that's already taken by all the operations we care about.
The single exception is rename. So, modify rename to take the i_mutex on the file that is being renamed.
Also fix up lockdep and Documentation/filesystems/directory-locking to reflect the change.
--- Documentation/filesystems/directory-locking | 31 +++++++++++++++++++-------- fs/namei.c | 10 ++++----- 2 files changed, 27 insertions(+), 14 deletions(-)
Documentation/filesystems/directory-locking +22 -9
@@ -2,6 +2,10 @@ kinds of locks - per-inode (->i_mutex) and per-filesystem (->s_vfs_rename_mutex). + When taking the i_mutex on multiple non-directory objects, we +always acquire the locks in order by increasing address. We'll call +that "inode pointer" order in the following. + For our purposes all operations fall in 5 classes: 1) read access. Locking rules: caller locks directory we are accessing.
@@ -12,8 +16,9 @@ kinds of locks - per-inode (->i_mutex) and per-filesystem locks victim and calls the method. 4) rename() that is _not_ cross-directory. Locking rules: caller locks -the parent, finds source and target, if target already exists - locks it -and then calls the method. +the parent and finds source and target. If target already exists, lock +it. If source is a non-directory, lock it. If that means we need to +lock both, lock them in inode pointer order. 5) link creation. Locking rules: * lock parent
@@ -30,7 +35,9 @@ rules: fail with -ENOTEMPTY * if new parent is equal to or is a descendent of source fail with -ELOOP - * if target exists - lock it. + * If target exists, lock it. If source is a non-directory, lock + it. In case that means we need to lock both source and target, + do so in inode pointer order. * call the method.
@@ -56,9 +63,11 @@ objects - A < B iff A is an ancestor of B. renames will be blocked on filesystem lock and we don't start changing the order until we had acquired all locks). -(3) any operation holds at most one lock on non-directory object and - that lock is acquired after all other locks. (Proof: see descriptions - of operations). +(3) locks on non-directory objects are acquired only after locks on + directory objects, and are acquired in inode pointer order. + (Proof: all operations but renames take lock on at most one + non-directory object, except renames, which take locks on source and + target in inode pointer order in the case they are not directories.) Now consider the minimal deadlock. Each process is blocked on attempt to acquire some lock and already holds at least one lock. Let's
@@ -66,9 +75,13 @@ consider the set of contended locks. First of all, filesystem lock is not contended, since any process blocked on it is not holding any locks. Thus all processes are blocked on ->i_mutex. - Non-directory objects are not contended due to (3). Thus link -creation can't be a part of deadlock - it can't be blocked on source -and it means that it doesn't hold any locks. + By (3), any process holding a non-directory lock can only be +waiting on another non-directory lock with a larger address. Therefore +the process holding the "largest" such lock can always make progress, and +non-directory objects are not included in the set of contended locks. + + Thus link creation can't be a part of deadlock - it can't be +blocked on source and it means that it doesn't hold any locks. Any contended object is either held by cross-directory rename or has a child that is also contended. Indeed, suppose that it is held by
fs/namei.c +5 -5
@@ -3935,7 +3935,8 @@ SYSCALL_DEFINE2(link, const char __user *, oldname, const char __user *, newname* That's where 4.4 screws up. Current fix: serialization on * sb->s_vfs_rename_mutex. We might be more accurate, but that's another * story. -* c) we have to lock _three_ objects - parents and victim (if it exists). +* c) we have to lock _four_ objects - parents and victim (if it exists), +* and source (if it is not a directory). * And that - after we got ->i_mutex on parents (until then we don't know * whether the target exists). Solution: try to be smart with locking * order for inodes. We rely on the fact that tree topology may change
@@ -4011,6 +4012,7 @@ static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { struct inode *target = new_dentry->d_inode; +struct inode *source = old_dentry->d_inode;int error; error =security_inode_rename (old_dir, old_dentry, new_dir, new_dentry);
@@ -4018,8 +4020,7 @@ static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,return error;dget (new_dentry); -if (target) -mutex_lock (&target->i_mutex); +lock_two_nondirectories (source, target); error = -EBUSY ;if (d_mountpoint (old_dentry)||d_mountpoint (new_dentry))
@@ -4034,8 +4035,7 @@ static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,if (!(old_dir->i_sb->s_type->fs_flags &FS_RENAME_DOES_D_MOVE ))d_move (old_dentry, new_dentry); out: -if (target) -mutex_unlock (&target->i_mutex); +unlock_two_nondirectories (source, target);dput (new_dentry);return error; }
Signature · 1 line
1.7.9.5
PATCH 7/13 namei: minor vfs_unlink cleanup
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
We'll be using dentry->d_inode in one more place.
--- fs/namei.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
fs/namei.c +4 -3
@@ -3638,6 +3638,7 @@ SYSCALL_DEFINE1(rmdir, const char __user *, pathname)int vfs_unlink (struct inode *dir,struct dentry *dentry) { +struct inode *target = dentry->d_inode;int error =may_delete (dir, dentry,0 );if (error)
@@ -3646,7 +3647,7 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry)if (!dir->i_op->unlink)return -EPERM ; -mutex_lock (&dentry->d_inode->i_mutex); +mutex_lock (&target->i_mutex);if (d_mountpoint (dentry)) error = -EBUSY ;else {
@@ -3657,11 +3658,11 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry)dont_mount (dentry); } } -mutex_unlock (&dentry->d_inode->i_mutex); +mutex_unlock (&target->i_mutex);/* We don't d_delete() NFS sillyrenamed files--they still exist. */ if (!error && !(dentry->d_flags &DCACHE_NFSFS_RENAMED )) { -fsnotify_link_count (dentry->d_inode); +fsnotify_link_count (target);d_delete (dentry); }
Signature · 1 line
1.7.9.5
PATCH 9/13 locks: helper functions for delegation breaking
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
We'll need the same logic for rename and link.
--- fs/namei.c | 13 +++---------- include/linux/fs.h | 33 +++++++++++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 12 deletions(-)
fs/namei.c +3 -10
@@ -3671,14 +3671,9 @@ int vfs_unlink(struct inode *dir, struct dentry *dentry, struct inode **delegateelse { error =security_inode_unlink (dir, dentry);if (!error) { - error =break_deleg (target,O_WRONLY |O_NONBLOCK ); -if (error) { -if (error == -EWOULDBLOCK && delegated_inode) { - *delegated_inode = target; -ihold (target); - } + error =try_break_deleg (target, delegated_inode); +if (error) goto out; - } error = dir->i_op->unlink (dir, dentry);if (!error)dont_mount (dentry);
@@ -3748,9 +3743,7 @@ exit2:iput (inode);/* truncate the inode here */ inode =NULL ;if (delegated_inode) { - error =break_deleg (delegated_inode,O_WRONLY ); -iput (delegated_inode); - delegated_inode =NULL ; + error =break_deleg_wait (&delegated_inode);if (!error) goto retry_deleg; }
include/linux/fs.h +31 -2
@@ -1906,6 +1906,9 @@ extern bool fs_fully_visible(struct file_system_type *);extern int current_umask (void ); +extern void ihold (struct inode * inode); +extern void iput (struct inode *); +/* /sys/fs */ extern struct kobject *fs_kobj;
@@ -1973,6 +1976,28 @@ static inline int break_deleg(struct inode *inode, unsigned int mode) return 0; } +static inline int try_break_deleg (struct inode *inode,struct inode **delegated_inode) +{ +int ret; + + ret =break_deleg (inode,O_WRONLY |O_NONBLOCK ); +if (ret == -EWOULDBLOCK && delegated_inode) { + *delegated_inode = inode; +ihold (inode); + } +return ret; +} + +static inline int break_deleg_wait (struct inode **delegated_inode) +{ +int ret; + + ret =break_deleg (*delegated_inode,O_WRONLY ); +iput (*delegated_inode); + *delegated_inode =NULL ; +return ret; +} +#else /* !CONFIG_FILE_LOCKING */ static inline int locks_mandatory_locked (struct inode *inode) {
@@ -2016,6 +2041,12 @@ static inline int break_deleg(struct inode *inode, unsigned int mode) {return 0 ; } + +static inline int try_break_deleg (struct inode *inode,struct delegated_inode **inode) +{ +return 0 ; +} +#endif /* CONFIG_FILE_LOCKING */ /* fs/open.c */
@@ -2351,8 +2382,6 @@ extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);extern int inode_init_always (struct super_block *,struct inode *);extern void inode_init_once (struct inode *);extern void address_space_init_once (struct address_space *mapping); -extern void ihold (struct inode * inode); -extern void iput (struct inode *);extern struct inode *igrab (struct inode *);extern ino_t iunique (struct super_block *,ino_t );extern int inode_needs_sync (struct inode *inode);
Signature · 1 line
1.7.9.5
PATCH 10/13 locks: break delegations on rename
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
--- fs/cachefiles/namei.c | 2 +- fs/namei.c | 47 +++++++++++++++++++++++++++++++++++++++++++---- fs/nfsd/vfs.c | 2 +- include/linux/fs.h | 2 +- 4 files changed, 46 insertions(+), 7 deletions(-)
fs/cachefiles/namei.c +1 -1
@@ -396,7 +396,7 @@ try_again:cachefiles_io_error (cache,"Rename security error %d" , ret); }else { ret =vfs_rename (dir->d_inode, rep, - cache->graveyard->d_inode, grave); + cache->graveyard->d_inode, grave,NULL );if (ret !=0 && ret != -ENOMEM )cachefiles_io_error (cache,"Rename failed with error %d" , ret);
fs/namei.c +43 -4
96 lines not on this page · raw message
fs/nfsd/vfs.c +1 -1
@@ -1838,7 +1838,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,if (host_err) goto out_dput_new; } - host_err =vfs_rename (fdir, odentry, tdir, ndentry); + host_err =vfs_rename (fdir, odentry, tdir, ndentry,NULL );if (!host_err) { host_err =commit_metadata (tfhp);if (!host_err)
include/linux/fs.h +1 -1
@@ -1468,7 +1468,7 @@ extern int vfs_symlink(struct inode *, struct dentry *, const char *);extern int vfs_link (struct dentry *,struct inode *,struct dentry *);extern int vfs_rmdir (struct inode *,struct dentry *);extern int vfs_unlink (struct inode *,struct dentry *,struct inode **); -extern int vfs_rename (struct inode *,struct dentry *,struct inode *,struct dentry *); +extern int vfs_rename (struct inode *,struct dentry *,struct inode *,struct dentry *,struct inode **);/* * VFS dentry helper functions.
Signature · 1 line
1.7.9.5
PATCH 11/13 locks: break delegations on link
In reply to J. Bruce FieldsFrom: "J. Bruce Fields" <[email protected]>
--- fs/ecryptfs/inode.c | 2 +- fs/namei.c | 36 ++++++++++++++++++++++++++++++++---- fs/nfsd/vfs.c | 2 +- include/linux/fs.h | 2 +- 4 files changed, 35 insertions(+), 7 deletions(-)
fs/ecryptfs/inode.c +1 -1
@@ -475,7 +475,7 @@ static int ecryptfs_link(struct dentry *old_dentry, struct inode *dir,dget (lower_new_dentry); lower_dir_dentry =lock_parent (lower_new_dentry); rc =vfs_link (lower_old_dentry, lower_dir_dentry->d_inode, - lower_new_dentry); + lower_new_dentry,NULL );if (rc || !lower_new_dentry->d_inode) goto out_lock; rc =ecryptfs_interpose (lower_new_dentry, new_dentry, dir->i_sb);
fs/namei.c +32 -4
@@ -3836,7 +3836,26 @@ SYSCALL_DEFINE2(symlink, const char __user *, oldname, const char __user *, newnreturn sys_symlinkat (oldname,AT_FDCWD , newname); } -int vfs_link (struct dentry *old_dentry,struct inode *dir,struct dentry *new_dentry) +/** +* vfs_link - create a new link +* @old_dentry: object to be linked +* @dir: new parent +* @new_dentry: where to create the new link +* @delegated_inode: returns inode needing a delegation break +* +* The caller must hold dir->i_mutex +* +* If vfs_link discovers a delegation on the to-be-linked file 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. +*/ +int vfs_link (struct dentry *old_dentry,struct inode *dir,struct dentry *new_dentry,struct inode **delegated_inode) {struct inode *inode = old_dentry->d_inode;unsigned max_links = dir->i_sb->s_max_links;
@@ -3872,8 +3891,11 @@ int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_de error = -ENOENT ; else if (max_links && inode->i_nlink >= max_links) error = -EMLINK ; - else - error = dir->i_op->link (old_dentry, dir, new_dentry); + else { + error =try_break_deleg (inode, delegated_inode); +if (!error) + error = dir->i_op->link (old_dentry, dir, new_dentry); + }if (!error && (inode->i_state &I_LINKABLE )) {spin_lock (&inode->i_lock);
@@ -3900,6 +3922,7 @@ SYSCALL_DEFINE5(linkat, int, olddfd, const char __user *, oldname, {struct dentry *new_dentry;struct path old_path, new_path; +struct inode *delegated_inode =NULL ;int how =0 ;int error;
@@ -3938,9 +3961,14 @@ retry: error =security_path_link (old_path.dentry, &new_path, new_dentry);if (error) goto out_dput; - error =vfs_link (old_path.dentry, new_path.dentry->d_inode, new_dentry); + error =vfs_link (old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode); out_dput:done_path_create (&new_path, new_dentry); +if (delegated_inode) { + error =break_deleg_wait (&delegated_inode); +if (!error) + goto retry; + }if (retry_estale (error, how)) { how |=LOOKUP_REVAL ; goto retry;
fs/nfsd/vfs.c +1 -1
@@ -1737,7 +1737,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, err =nfserrno (host_err); goto out_dput; } - host_err =vfs_link (dold, dirp, dnew); + host_err =vfs_link (dold, dirp, dnew,NULL );if (!host_err) { err =nfserrno (commit_metadata (ffhp));if (!err)
include/linux/fs.h +1 -1
@@ -1465,7 +1465,7 @@ extern int vfs_create(struct inode *, struct dentry *, umode_t, bool);extern int vfs_mkdir (struct inode *,struct dentry *,umode_t );extern int vfs_mknod (struct inode *,struct dentry *,umode_t ,dev_t );extern int vfs_symlink (struct inode *,struct dentry *,const char *); -extern int vfs_link (struct dentry *,struct inode *,struct dentry *); +extern int vfs_link (struct dentry *,struct inode *,struct dentry *,struct inode **);extern int vfs_rmdir (struct inode *,struct dentry *);extern int vfs_unlink (struct inode *,struct dentry *,struct inode **);extern int vfs_rename (struct inode *,struct dentry *,struct inode *,struct dentry *,struct inode **);
Signature · 1 line
1.7.9.5
PATCH 13/13 locks: close potential race between setlease and open
In reply to J. Bruce FieldsFrom: Jeff Layton <[email protected]>
v2:
- fix potential double-free of lease if second check finds conflict
- add smp_mb's to ensure that other CPUs see i_flock changes
v3:
- remove smp_mb calls. Partial ordering is unlikely to help here.
v4:
- add back smp_mb calls. While we have implicit barriers in place that enforce this today, it's best to be explicit about it as a defensive coding measure.
As Al Viro points out, there is an unlikely, but possible race between opening a file and setting a lease on it. generic_add_lease is done with the i_lock held, but the inode->i_flock check in break_lease is lockless. It's possible for another task doing an open to do the entire pathwalk and call break_lease between the point where generic_add_lease checks for a conflicting open and adds the lease to the list. If this occurs, we can end up with a lease set on the file with a conflicting open.
To guard against that, check again for a conflicting open after adding the lease to the i_flock list. If the above race occurs, then we can simply unwind the lease setting and return -EAGAIN.
Because we take dentry references and acquire write access on the file before calling break_lease, we know that if the i_flock list is empty when the open caller goes to check it then the necessary refcounts have already been incremented. Thus the additional check for a conflicting open will see that there is one and the setlease call will fail.
--- fs/locks.c | 75 +++++++++++++++++++++++++++++++++++++++++++--------- include/linux/fs.h | 6 +++++ 2 files changed, 68 insertions(+), 13 deletions(-)
fs/locks.c +62 -13
@@ -652,15 +652,18 @@ static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)locks_insert_global_locks (fl); } -/* -* Delete a lock and then free it. -* Wake up processes that are blocked waiting for this lock, -* notify the FS that the lock has been cleared and -* finally free the lock. +/** +* locks_delete_lock - Delete a lock and then free it. +* @thisfl_p: pointer that points to the fl_next field of the previous +* inode->i_flock list entry +* +* Unlink a lock from all lists and free the namespace reference, but don't +* free it yet. Wake up processes that are blocked waiting for this lock and +* notify the FS that the lock has been cleared. * * Must be called with the i_lock held! */ -static void locks_delete_lock (struct file_lock **thisfl_p) +static void locks_unlink_lock (struct file_lock **thisfl_p) {struct file_lock *fl = *thisfl_p;
@@ -675,6 +678,18 @@ static void locks_delete_lock(struct file_lock **thisfl_p) }locks_wake_up_blocks (fl); +} + +/* +* Unlink a lock from all lists and free it. +* +* Must be called with i_lock held! +*/ +static void locks_delete_lock (struct file_lock **thisfl_p) +{ +struct file_lock *fl = *thisfl_p; + +locks_unlink_lock (thisfl_p);locks_free_lock (fl); }
@@ -1472,6 +1487,32 @@ int fcntl_getlease(struct file *filp)return type; } +/** +* check_conflicting_open - see if the given dentry points to a file that has +* an existing open that would conflict with the +* desired lease. +* @dentry: dentry to check +* @arg: type of lease that we're trying to acquire +* +* Check to see if there's an existing open fd on this file that would +* conflict with the lease we're trying to set. +*/ +static int +check_conflicting_open (const struct dentry *dentry,const long arg) +{ +int ret =0 ; +struct inode *inode = dentry->d_inode; + +if ((arg ==F_RDLCK ) && (atomic_read (&inode->i_writecount) >0 )) +return -EAGAIN ; + +if ((arg ==F_WRLCK ) && ((d_count (dentry) >1 ) || + (atomic_read (&inode->i_count) >1 ))) + ret = -EAGAIN ; + +return ret; +} +static int generic_add_lease (struct file *filp,long arg,struct file_lock **flp) {struct file_lock *fl, **before, **my_before =NULL , *lease;
@@ -1498,12 +1539,8 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flpreturn -EINVAL ; } - error = -EAGAIN ; -if ((arg ==F_RDLCK ) && (atomic_read (&inode->i_writecount) >0 )) - goto out; -if ((arg ==F_WRLCK ) - && ((d_count (dentry) >1 ) - || (atomic_read (&inode->i_count) >1 ))) + error =check_conflicting_open (dentry, arg); +if (error) goto out;/*
@@ -1548,7 +1585,19 @@ static int generic_add_lease(struct file *filp, long arg, struct file_lock **flp goto out;locks_insert_lock (before, lease); - error =0 ; +/* +* The check in break_lease() is lockless. It's possible for another +* open to race in after we did the earlier check for a conflicting +* open but before the lease was inserted. Check again for a +* conflicting open and cancel the lease if there is one. +* +* We also add a barrier here to ensure that the insertion of the lock +* precedes these checks. +*/ +smp_mb (); + error =check_conflicting_open (dentry, arg); +if (error) +locks_unlink_lock (flp); out:if (is_deleg)mutex_unlock (&inode->i_mutex);
include/linux/fs.h +6 -0
@@ -1964,6 +1964,12 @@ static inline int locks_verify_truncate(struct inode *inode,static inline int break_lease (struct inode *inode,unsigned int mode) { +/* +* Since this check is lockless, we must ensure that any refcounts +* taken are done before checking inode->i_flock. Otherwise, we could +* end up racing with tasks trying to set a new lease on this file. +*/ +smp_mb ();if (inode->i_flock)return __break_lease (inode, mode,FL_LEASE );return 0 ;
Signature · 1 line
1.7.9.5
Quoted 3 lines · J. Bruce Fields
From: "J. Bruce Fields" <[email protected]>
Al, if you don't see any objections, could you queue this up for 3.13?
Note: if it's more convenient, the identical patches are also available from
git://linux-nfs.org/~bfields/linux.git for-viro
--b.
Quoted 89 lines
Changes since version 11:
- rebase to 3.12-rc1
- fix to lock class in single-lock case oflock_two_nondirectoriesChanges since version 10:
- appended Jeff's fix for a setlease/open race (otherwise unrelated to this series, but there are some minor conficts to resolve).Changes since version 9:
- just a rebase to 3.11-rc6Changes since version 8:
- additional warnings inlock_two_nondirectories
-lock_two_nondirectorieshandles NULL second argument, simplifyingvfs_rename_other
- kerneldoc comments onnotify_change,vfs_link,vfs_rename,vfs_unlink, to explaindelegated_inodeargument.
- make clear non-support of write delegations ingeneric_add_lease
- rebase to 3.11-rc1Introduction copied from previous posting:
This patch series implements read delegations, which allow NFSv4 clients to perform read opens without contacting the server, by promising to call back to clients before modifying the data, metadata, or set of links pointing to a file.
The main recent change was in response to review from Linus, who didn't want us to hang under directory i_mutex's on timeouts communicating with unresponsive clients.
So, this version of the series drops the
i_mutexbefore waiting. The logic ends up looking something like:acquire locks
look up inode
test for delegation; if found:
take reference on inode
release locks
wait for delegation break
drop reference on inode
retryThe initial test for a delegation happens after the lock on the delegated inode is acquired, but additional directory mutexes may have been acquired further up the call stack. I therefore add a "struct inode **" argument to any intervening functions, which we use to pass the inode back up to the caller in the case it needs to wait for the delegation to be broken.
I also allow callers to pass in NULL for the "struct inode **" argument to indicate they'd rather just fail than wait for a delegation. For example, as long as ecryptfs isn't exportable I assume they'd rather not see retry logic there that they won't use. But I may have misjudged in some of these cases.
J. Bruce Fields (12):
vfs: pull ext4's double-i_mutex-locking into common code
vfs: don't use PARENT/CHILD lock classes for non-directories
vfs: renameI_MUTEX_QUOTAnow that it's not used for quotas
vfs: takei_mutexon renamed file
locks: introduce newFL_DELEGlock flag
locks: implement delegations
namei: minorvfs_unlinkcleanup
locks: break delegations on unlink
locks: helper functions for delegation breaking
locks: break delegations on rename
locks: break delegations on link
locks: break delegations on any attribute modificationJeff Layton (1):
locks: close potential race between setlease and openDocumentation/filesystems/directory-locking | 31 ++++-- drivers/base/devtmpfs.c | 6 +- fs/attr.c | 25 ++++- fs/cachefiles/interface.c | 4 +- fs/cachefiles/namei.c | 4 +- fs/ecryptfs/inode.c | 6 +- fs/ext4/ext4.h | 2 - fs/ext4/ioctl.c | 4 +- fs/ext4/move_extent.c | 40 +------- fs/hpfs/namei.c | 2 +- fs/inode.c | 42 ++++++++- fs/locks.c | 130 +++++++++++++++++++++-----
Quoted 16 lines
fs/namei.c | 135 +++++++++++++++++++++++---- fs/nfsd/nfs4state.c | 2 +- fs/nfsd/vfs.c | 14 ++- fs/open.c | 22 ++++- fs/utimes.c | 9 +- include/linux/fs.h | 78 +++++++++++++--- ipc/mqueue.c | 2 +- 19 files changed, 428 insertions(+), 130 deletions(-)Signature · 6 lines
1.7.9.5 -- To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 9 lines · bfields
Quoted 3 lines · J. Bruce Fields
From: "J. Bruce Fields" <[email protected]>
Al, if you don't see any objections, could you queue this up for 3.13?
Note: if it's more convenient, the identical patches are also available from
git://linux-nfs.org/~bfields/linux.gitfor-viro
But kbuild points out I forgot to fix up some calls in ecryptfs.
I'll push out another version with the below folded in, once I've checked whether there's anything else I touched that got turned off in my test .config....
--b.
fs/ecryptfs/inode.c +4 -3
@@ -208,7 +208,7 @@ ecryptfs_do_create(struct inode *directory_inode, inode =__ecryptfs_get_inode (lower_dentry->d_inode, directory_inode->i_sb);if (IS_ERR (inode)) { -vfs_unlink (lower_dir_dentry->d_inode, lower_dentry); +vfs_unlink (lower_dir_dentry->d_inode, lower_dentry,NULL ); goto out_lock; }fsstack_copy_attr_times (directory_inode, lower_dir_dentry->d_inode);
@@ -640,7 +640,8 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry, goto out_lock; } rc =vfs_rename (lower_old_dir_dentry->d_inode, lower_old_dentry, - lower_new_dir_dentry->d_inode, lower_new_dentry); + lower_new_dir_dentry->d_inode, lower_new_dentry, +NULL );if (rc) goto out_lock;if (target_inode)
@@ -891,7 +892,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;
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 9 lines · J. Bruce Fields
Quoted 8 lines · bfields
Quoted 3 lines · J. Bruce Fields
From: "J. Bruce Fields" <[email protected]>
Al, if you don't see any objections, could you queue this up for 3.13?
Note: if it's more convenient, the identical patches are also available from
Quoted 7 lines
Quoted 1 line
git://linux-nfs.org/~bfields/linux.gitfor-viroBut kbuild points out I forgot to fix up some calls in ecryptfs.
I'll push out another version with the below folded in, once I've checked whether there's anything else I touched that got turned off in my test .config....
Done; the change below is now folded into the commits on the for-viro branch at the url above.
--b.
Quoted 35 lines
--b.
fs/ecryptfs/inode.c +4
-3@@ -208,7 +208,7 @@ ecryptfs_do_create(struct inode *directory_inode, inode =__ecryptfs_get_inode (lower_dentry->d_inode, directory_inode->i_sb);if (IS_ERR (inode)) { -vfs_unlink (lower_dir_dentry->d_inode, lower_dentry); +vfs_unlink (lower_dir_dentry->d_inode, lower_dentry,NULL ); goto out_lock; }fsstack_copy_attr_times (directory_inode, lower_dir_dentry->d_inode);@@ -640,7 +640,8 @@ ecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry, goto out_lock; } rc =vfs_rename (lower_old_dir_dentry->d_inode, lower_old_dentry, - lower_new_dir_dentry->d_inode, lower_new_dentry); + lower_new_dir_dentry->d_inode, lower_new_dentry, +NULL );if (rc) goto out_lock;if (target_inode)@@ -891,7 +892,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;
Quoted 12 lines · J. Bruce Fields
Quoted 11 lines · J. Bruce Fields
Quoted 9 lines · bfields
Quoted 3 lines · J. Bruce Fields
From: "J. Bruce Fields" <[email protected]>
Al, if you don't see any objections, could you queue this up for 3.13?
Note: if it's more convenient, the identical patches are also available from
git://linux-nfs.org/~bfields/linux.gitfor-viro
Quoted 8 lines
Quoted 5 lines
But kbuild points out I forgot to fix up some calls in ecryptfs.
I'll push out another version with the below folded in, once I've checked whether there's anything else I touched that got turned off in my test .config....
Done; the change below is now folded into the commits on the for-viro branch at the url above.
And kbuild also pointed out a typo in the !CONFIG_FILE_LOCKING case, also now fixed in the git tree above.
I've also added two previously posted sets of patches to that branch for you to cherry-pick as you'd like:
- miscellaneous DCACHE_DISCONECTED fixes
http://mid.gmane.org/<[email protected]>
- problem looking up filehandles with 64-bit inodes
http://mid.gmane.org/<[email protected]>
--b.