xfs: Remove wrappers for some semaphores
v11 cover xfs: Remove wrappers for some semaphores
Remove some wrappers that we have in XFS around the read-write semaphore locks.
The goal of this cleanup is to remove mrlock_t structure and its mr*() wrapper functions and replace it with native rw_semaphore type and its native calls.
Changes in version 8:
* Patchset was rebased so it applies cleanly.
* The patch 'xfs: replace mrlock_t with rw_semaphores' contains change in xfs_btree.c which transfers ownership of lock so lockdep won't assert (This was reported by Darrick and proposed change fixes this issue).
Changes in version 9:
*Fixed white space in patch 'xfs: Refactor xfs_isilocked()'
*Updated code comments as suggested by djwong (thanks!) in patch: 'xfs: replace mrlock_t with rw_semaphores'
Changes in version 10:
* Fixed use-after-free in 'xfs: replace mrlock_t with rw_semaphores' (thanks Darrick)
* Moved part of refactor of xfs_isilocked() from patch 'xfs: Refactor xfs_isilocked()' to patch 'xfs: replace mrlock_t with rw_semaphores' - to fix compilation error
* Typo in comment in 'xfs: replace mrlock_t with rw_semaphores'
Changes in version 11:
* Dropped typedef xfs_node_t from xfs_isilocked in 'xfs: Refactor xfs_isilocked()'
Pavel Reichl (4):
xfs: Refactor xfs_isilocked()
xfs: clean up whitespace in xfs_isilocked() calls
xfs: xfs_isilocked() can only check a single lock type
xfs: replace mrlock_t with rw_semaphores
fs/xfs/libxfs/xfs_bmap.c | 8 +-- fs/xfs/libxfs/xfs_btree.c | 24 +++++++++ fs/xfs/mrlock.h | 78 ----------------------------- fs/xfs/xfs_file.c | 3 +- fs/xfs/xfs_inode.c | 102 +++++++++++++++++++++++++------------- fs/xfs/xfs_inode.h | 25 ++++++---- fs/xfs/xfs_iops.c | 4 +- fs/xfs/xfs_linux.h | 2 +- fs/xfs/xfs_qm.c | 2 +- fs/xfs/xfs_super.c | 6 +-- 10 files changed, 121 insertions(+), 133 deletions(-) delete mode 100644 fs/xfs/mrlock.h
Signature · 1 line
2.26.2
PATCH v11 1/4 xfs: Refactor xfs_isilocked()
Refactor xfs_isilocked() to use newly introduced __xfs_rwsem_islocked(). __xfs_rwsem_islocked() is a helper function which encapsulates checking state of rw_semaphores hold by inode.
--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)
fs/xfs/xfs_inode.c +40 -8
@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access +* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + } + +return lockdep_is_held_type (rwsem, arg); +} + +bool xfs_isilocked ( -xfs_inode_t *ip, +struct xfs_inode *ip,uint lock_flags) {if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) {
@@ -362,15 +396,13 @@ xfs_isilocked( return rwsem_is_locked(&ip->i_mmaplock.mr_lock); } -if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) { -if (!(lock_flags &XFS_IOLOCK_SHARED )) -return !debug_locks || -lockdep_is_held_type (&VFS_I (ip)->i_rwsem,0 ); -return rwsem_is_locked (&VFS_I (ip)->i_rwsem); +if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) { +return __xfs_rwsem_islocked (&VFS_I (ip)->i_rwsem, + (lock_flags >>XFS_IOLOCK_FLAG_SHIFT )); }ASSERT (0 ); -return 0 ; +return false; }#endif
fs/xfs/xfs_inode.h +14 -7
@@ -268,12 +268,19 @@ static inline void xfs_ifunlock(struct xfs_inode *ip)* Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield) * 1<<16 - 1<<32-1 -- lockdep annotation (integers) */ -#define XFS_IOLOCK_EXCL (1<<0) -#define XFS_IOLOCK_SHARED (1<<1) -#define XFS_ILOCK_EXCL (1<<2) -#define XFS_ILOCK_SHARED (1<<3) -#define XFS_MMAPLOCK_EXCL (1<<4) -#define XFS_MMAPLOCK_SHARED (1<<5) + +#define XFS_IOLOCK_FLAG_SHIFT 0 +#define XFS_ILOCK_FLAG_SHIFT 2 +#define XFS_MMAPLOCK_FLAG_SHIFT 4 + +#define XFS_SHARED_LOCK_SHIFT 1 + +#define XFS_IOLOCK_EXCL (1 << (XFS_IOLOCK_FLAG_SHIFT)) +#define XFS_IOLOCK_SHARED (XFS_IOLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_ILOCK_EXCL (1 << (XFS_ILOCK_FLAG_SHIFT)) +#define XFS_ILOCK_SHARED (XFS_ILOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_MMAPLOCK_EXCL (1 << (XFS_MMAPLOCK_FLAG_SHIFT)) +#define XFS_MMAPLOCK_SHARED (XFS_MMAPLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT))#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \
@@ -412,7 +419,7 @@ void xfs_ilock(xfs_inode_t *, uint);int xfs_ilock_nowait (xfs_inode_t *,uint );void xfs_iunlock (xfs_inode_t *,uint );void xfs_ilock_demote (xfs_inode_t *,uint ); -int xfs_isilocked (xfs_inode_t *,uint ); +bool xfs_isilocked (struct xfs_inode *,uint );uint xfs_ilock_data_map_shared (struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *);
Signature · 1 line
2.26.2
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
Quoted 43 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +20
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case.
fs/xfs/xfs_inode.c xfs_ilock_demote( · line 377
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access +* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + }
Are these arg values documented somewhere? A quick look at the function below didn't show anything..
Also, I find the pattern of shifting in the caller slightly confusing, particularly with the 'lock_flags' name being passed down through the caller. Any reason we couldn't pass the shift value as a parameter and do the shift at the top of the function so the logic is clear and in one place?
Quoted 11 lines
fs/xfs/xfs_inode.c +6
-1+ +return lockdep_is_held_type (rwsem, arg); +} + +bool xfs_isilocked ( - xfs_inode_t *ip, +struct xfs_inode *ip,uint lock_flags) {if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) {
...
Quoted 18 lines
fs/xfs/xfs_inode.h +4
-6@@ -268,12 +268,19 @@ static inline void xfs_ifunlock(struct xfs_inode *ip)* Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield) * 1<<16 - 1<<32-1 -- lockdep annotation (integers) */ -#define XFS_IOLOCK_EXCL (1<<0) -#define XFS_IOLOCK_SHARED (1<<1) -#define XFS_ILOCK_EXCL (1<<2) -#define XFS_ILOCK_SHARED (1<<3) -#define XFS_MMAPLOCK_EXCL (1<<4) -#define XFS_MMAPLOCK_SHARED (1<<5) + +#define XFS_IOLOCK_FLAG_SHIFT 0 +#define XFS_ILOCK_FLAG_SHIFT 2 +#define XFS_MMAPLOCK_FLAG_SHIFT 4
fs/xfs/xfs_inode.h static inline void xfs_ifunlock(struct xfs_inode *ip) · line 284
Quoted 10 lines
fs/xfs/xfs_inode.h +9
-0+ +#define XFS_SHARED_LOCK_SHIFT 1 + +#define XFS_IOLOCK_EXCL (1 << (XFS_IOLOCK_FLAG_SHIFT)) +#define XFS_IOLOCK_SHARED (XFS_IOLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_ILOCK_EXCL (1 << (XFS_ILOCK_FLAG_SHIFT)) +#define XFS_ILOCK_SHARED (XFS_ILOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_MMAPLOCK_EXCL (1 << (XFS_MMAPLOCK_FLAG_SHIFT)) +#define XFS_MMAPLOCK_SHARED (XFS_MMAPLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT))
Any reason for the extra params around the shift values?
Brian
Quoted 14 lines
fs/xfs/xfs_inode.h +1
-1#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \@@ -412,7 +419,7 @@ void xfs_ilock(xfs_inode_t *, uint);int xfs_ilock_nowait (xfs_inode_t *,uint );void xfs_iunlock (xfs_inode_t *,uint );void xfs_ilock_demote (xfs_inode_t *,uint ); -int xfs_isilocked (xfs_inode_t *,uint ); +bool xfs_isilocked (struct xfs_inode *,uint );uint xfs_ilock_data_map_shared (struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *);Signature · 1 line
2.26.2
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
Quoted 49 lines · Brian Foster
Quoted 48 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +25
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access
Quoted 8 lines
fs/xfs/xfs_inode.c xfs_ilock_demote( · line 377
Quoted 5 lines
fs/xfs/xfs_inode.c +5
-0+* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + }Are these arg values documented somewhere? A quick look at the function below didn't show anything..
Alas, no. :(
If you trace lockdep_is_held_type -> lock_is_held_type -> __lock_is_held then you'll notice that "if (read == -1" bit, but none of those functions are documented.
So I have no if that's /really/ permanent, other than to say that it exists because Dave and Christoph and I requested it years ago and commit f8319483f57f1 has been unchanged since 2016.
--D
Quoted 66 lines
Also, I find the pattern of shifting in the caller slightly confusing, particularly with the '
lock_flags' name being passed down through the caller. Any reason we couldn't pass the shift value as a parameter and do the shift at the top of the function so the logic is clear and in one place?Quoted 11 lines
fs/xfs/xfs_inode.c +6
-1+ +return lockdep_is_held_type (rwsem, arg); +} + +bool xfs_isilocked ( - xfs_inode_t *ip, +struct xfs_inode *ip,uint lock_flags) {if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) {...
Quoted 18 lines
fs/xfs/xfs_inode.h +4
-6@@ -268,12 +268,19 @@ static inline void xfs_ifunlock(struct xfs_inode *ip)* Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield) * 1<<16 - 1<<32-1 -- lockdep annotation (integers) */ -#define XFS_IOLOCK_EXCL (1<<0) -#define XFS_IOLOCK_SHARED (1<<1) -#define XFS_ILOCK_EXCL (1<<2) -#define XFS_ILOCK_SHARED (1<<3) -#define XFS_MMAPLOCK_EXCL (1<<4) -#define XFS_MMAPLOCK_SHARED (1<<5) + +#define XFS_IOLOCK_FLAG_SHIFT 0 +#define XFS_ILOCK_FLAG_SHIFT 2 +#define XFS_MMAPLOCK_FLAG_SHIFT 4fs/xfs/xfs_inode.h static inline void xfs_ifunlock(struct xfs_inode *ip) · line 284
Quoted 10 lines
fs/xfs/xfs_inode.h +9
-0+ +#define XFS_SHARED_LOCK_SHIFT 1 + +#define XFS_IOLOCK_EXCL (1 << (XFS_IOLOCK_FLAG_SHIFT)) +#define XFS_IOLOCK_SHARED (XFS_IOLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_ILOCK_EXCL (1 << (XFS_ILOCK_FLAG_SHIFT)) +#define XFS_ILOCK_SHARED (XFS_ILOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_MMAPLOCK_EXCL (1 << (XFS_MMAPLOCK_FLAG_SHIFT)) +#define XFS_MMAPLOCK_SHARED (XFS_MMAPLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT))Any reason for the extra params around the shift values?
Brian
Quoted 14 lines
fs/xfs/xfs_inode.h +1
-1#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \@@ -412,7 +419,7 @@ void xfs_ilock(xfs_inode_t *, uint);int xfs_ilock_nowait (xfs_inode_t *,uint );void xfs_iunlock (xfs_inode_t *,uint );void xfs_ilock_demote (xfs_inode_t *,uint ); -int xfs_isilocked (xfs_inode_t *,uint ); +bool xfs_isilocked (struct xfs_inode *,uint );uint xfs_ilock_data_map_shared (struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *);Signature · 1 line
2.26.2
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
Quoted 59 lines · Darrick J. Wong
Quoted 49 lines · Brian Foster
Quoted 48 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +25
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access Quoted 8 lines
fs/xfs/xfs_inode.c xfs_ilock_demote( · line 377
Quoted 5 lines
fs/xfs/xfs_inode.c +5
-0+* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + }Are these arg values documented somewhere? A quick look at the function below didn't show anything..
Quoted 6 lines
Alas, no. :(
If you trace
lockdep_is_held_type->lock_is_held_type->__lock_is_heldthen you'll notice that "if (read == -1" bit, but none of those functions are documented.
Ok, so -1 is basically a catchall that causes lockdep to tell us whether the lock is held or not (in any mode). Any other value is presumably defined by the lockdep tracking infrastructure since it directly compares to ->read.
Hmm.. lockdep.h has this:
#define lock_acquire_exclusive(l, s, t, n, i) lock_acquire(l, s, t, 0, 1, n, i) #define lock_acquire_shared(l, s, t, n, i) lock_acquire(l, s, t, 1, 1, n, i) #define lock_acquire_shared_recursive(l, s, t, n, i) lock_acquire(l, s, t, 2, 1, n, i)
... which at least seems to correlate the values with modes (0 == exclusive, 1 || 2 == shared, etc.). I think an additional sentence or two on that in our comments would be helpful for the next person that needs to grok this code. For example, something like the following (which factors in the above two comments and IMO is slightly more clear):
"If the shared flag is not set, pass 0 to explicitly check for exclusive access to the lock. If the shared flag is set, we typically want to make sure the lock is at least held in shared mode (i.e., shared | excl) but we don't necessarily care that it might actually be held exclusive. Therefore, pass -1 to check whether the lock is held in any mode rather than one of the explicit shared mode values (1 or 2)."
Brian
Quoted 73 lines
So I have no if that's /really/ permanent, other than to say that it exists because Dave and Christoph and I requested it years ago and commit
f8319483f57f1has been unchanged since 2016.--D
Quoted 66 lines
Also, I find the pattern of shifting in the caller slightly confusing, particularly with the '
lock_flags' name being passed down through the caller. Any reason we couldn't pass the shift value as a parameter and do the shift at the top of the function so the logic is clear and in one place?Quoted 11 lines
fs/xfs/xfs_inode.c +6
-1+ +return lockdep_is_held_type (rwsem, arg); +} + +bool xfs_isilocked ( - xfs_inode_t *ip, +struct xfs_inode *ip,uint lock_flags) {if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) {...
Quoted 18 lines
fs/xfs/xfs_inode.h +4
-6@@ -268,12 +268,19 @@ static inline void xfs_ifunlock(struct xfs_inode *ip)* Bit ranges: 1<<1 - 1<<16-1 -- iolock/ilock modes (bitfield) * 1<<16 - 1<<32-1 -- lockdep annotation (integers) */ -#define XFS_IOLOCK_EXCL (1<<0) -#define XFS_IOLOCK_SHARED (1<<1) -#define XFS_ILOCK_EXCL (1<<2) -#define XFS_ILOCK_SHARED (1<<3) -#define XFS_MMAPLOCK_EXCL (1<<4) -#define XFS_MMAPLOCK_SHARED (1<<5) + +#define XFS_IOLOCK_FLAG_SHIFT 0 +#define XFS_ILOCK_FLAG_SHIFT 2 +#define XFS_MMAPLOCK_FLAG_SHIFT 4fs/xfs/xfs_inode.h static inline void xfs_ifunlock(struct xfs_inode *ip) · line 284
Quoted 10 lines
fs/xfs/xfs_inode.h +9
-0+ +#define XFS_SHARED_LOCK_SHIFT 1 + +#define XFS_IOLOCK_EXCL (1 << (XFS_IOLOCK_FLAG_SHIFT)) +#define XFS_IOLOCK_SHARED (XFS_IOLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_ILOCK_EXCL (1 << (XFS_ILOCK_FLAG_SHIFT)) +#define XFS_ILOCK_SHARED (XFS_ILOCK_EXCL << (XFS_SHARED_LOCK_SHIFT)) +#define XFS_MMAPLOCK_EXCL (1 << (XFS_MMAPLOCK_FLAG_SHIFT)) +#define XFS_MMAPLOCK_SHARED (XFS_MMAPLOCK_EXCL << (XFS_SHARED_LOCK_SHIFT))Any reason for the extra params around the shift values?
Brian
Quoted 14 lines
fs/xfs/xfs_inode.h +1
-1#define XFS_LOCK_MASK (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \ | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \@@ -412,7 +419,7 @@ void xfs_ilock(xfs_inode_t *, uint);int xfs_ilock_nowait (xfs_inode_t *,uint );void xfs_iunlock (xfs_inode_t *,uint );void xfs_ilock_demote (xfs_inode_t *,uint ); -int xfs_isilocked (xfs_inode_t *,uint ); +bool xfs_isilocked (struct xfs_inode *,uint );uint xfs_ilock_data_map_shared (struct xfs_inode *);uint xfs_ilock_attr_map_shared (struct xfs_inode *);Signature · 1 line
2.26.2
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
In reply to Brian FosterQuoted 54 lines · Brian Foster
Quoted 53 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +30
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access +* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + }
...
Quoted 7 lines
Also, I find the pattern of shifting in the caller slightly confusing, particularly with the '
lock_flags' name being passed down through the caller. Any reason we couldn't pass the shift value as a parameter and do the shift at the top of the function so the logic is clear and in one place?
Hi Brian, is following change what you had in mind? Thanks!
Quoted 1 line
fs/xfs/xfs_inode.c xfs_ilock_demote(
Quoted 1 line
fs/xfs/xfs_inode.c +0
-0@@ -349,14 +349,16 @@ xfs_ilock_demote(
static inline bool
__xfs_rwsem_islocked(
struct rw_semaphore *rwsem,
- int lock_flags)
+ int lock_flags,
+ int shift)
{
int arg;
+ const int shifted_lock_flags = lock_flags >> shift;
if (!debug_locks)
return rwsem_is_locked(rwsem);
- if (lock_flags & (1 << XFS_SHARED_LOCK_SHIFT)) {
+ if (shifted_lock_flags & (1 << XFS_SHARED_LOCK_SHIFT)) {
/*
* The caller could be asking if we have (shared | excl)
* access to the lock. Ask lockdep if the rwsem is
@@ -387,20 +389,20 @@ xfs_isilocked(
{
if (lock_flags & (XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)) {
ASSERT(!(lock_flags & ~(XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)));
- return __xfs_rwsem_islocked(&ip->i_lock,
- (lock_flags >> XFS_ILOCK_FLAG_SHIFT));
+ return __xfs_rwsem_islocked(&ip->i_lock, lock_flags,
+ XFS_ILOCK_FLAG_SHIFT);
}
if (lock_flags & (XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)) {
ASSERT(!(lock_flags &
~(XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)));
- return __xfs_rwsem_islocked(&ip->i_mmaplock,
- (lock_flags >> XFS_MMAPLOCK_FLAG_SHIFT));
+ return __xfs_rwsem_islocked(&ip->i_mmaplock, lock_flags,
+ XFS_MMAPLOCK_FLAG_SHIFT);
}
if (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) {
- return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem,
- (lock_flags >> XFS_IOLOCK_FLAG_SHIFT));
+ return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem, lock_flags,
+ XFS_IOLOCK_FLAG_SHIFT);
}
ASSERT(0);
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
Quoted 59 lines · Pavel Reichl
Quoted 54 lines · Brian Foster
Quoted 53 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +30
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ; + }else { +/* +* The caller is asking if we have only exclusive access +* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + }...
Quoted 1 line
Quoted 9 lines
Quoted 6 lines
Also, I find the pattern of shifting in the caller slightly confusing, particularly with the '
lock_flags' name being passed down through the caller. Any reason we couldn't pass the shift value as a parameter and do the shift at the top of the function so the logic is clear and in one place?Hi Brian, is following change what you had in mind? Thanks!
Yep, pretty much. I find shifted_lock_flags to be a little verbose as a name. I'd be fine with just doing something like 'lock_flags >>= shift' near the top of the function, but that's more of a personal nit. I also like Christoph's suggestion to avoid the arg variable (along with the comment update suggested in the discussion with Darrick).
Brian
Quoted 48 lines
Quoted 2 lines
fs/xfs/xfs_inode.c xfs_ilock_demote(
Quoted 2 lines
fs/xfs/xfs_inode.c +0
-0@@ -349,14 +349,16 @@ xfs_ilock_demote(static inline bool
__xfs_rwsem_islocked((quoted diff) +10
-8struct rw_semaphore *rwsem, - int lock_flags) + int lock_flags, + int shift) { int arg; + const int shifted_lock_flags = lock_flags >> shift; if (!debug_locks) return rwsem_is_locked(rwsem); - if (lock_flags & (1 << XFS_SHARED_LOCK_SHIFT)) { + if (shifted_lock_flags & (1 << XFS_SHARED_LOCK_SHIFT)) { /* * The caller could be asking if we have (shared | excl) * access to the lock. Ask lockdep if the rwsem is@@ -387,20 +389,20 @@ xfs_isilocked( { if (lock_flags & (XFS_ILOCK_EXCL | XFS_ILOCK_SHARED)) { ASSERT(!(lock_flags & ~(XFS_ILOCK_EXCL | XFS_ILOCK_SHARED))); - return __xfs_rwsem_islocked(&ip->i_lock, - (lock_flags >> XFS_ILOCK_FLAG_SHIFT)); + return __xfs_rwsem_islocked(&ip->i_lock, lock_flags, + XFS_ILOCK_FLAG_SHIFT); } if (lock_flags & (XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)) { ASSERT(!(lock_flags & ~(XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED))); - return __xfs_rwsem_islocked(&ip->i_mmaplock, - (lock_flags >> XFS_MMAPLOCK_FLAG_SHIFT)); + return __xfs_rwsem_islocked(&ip->i_mmaplock, lock_flags, + XFS_MMAPLOCK_FLAG_SHIFT); } if (lock_flags & (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED)) { - return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem, - (lock_flags >> XFS_IOLOCK_FLAG_SHIFT)); + return __xfs_rwsem_islocked(&VFS_I(ip)->i_rwsem, lock_flags, + XFS_IOLOCK_FLAG_SHIFT); } ASSERT(0);
Re: [PATCH v11 1/4] xfs: Refactor xfs_isilocked()
In reply to Pavel ReichlQuoted 45 lines · Pavel Reichl
Refactor
xfs_isilocked()to use newly introduced__xfs_rwsem_islocked().__xfs_rwsem_islocked()is a helper function which encapsulates checking state ofrw_semaphoreshold by inode.Signed-off-by Pavel Reichl <[email protected]>Suggested-by Dave Chinner <[email protected]>Suggested-by Eric Sandeen <[email protected]>Suggested-by Darrick J. Wong <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>--- fs/xfs/xfs_inode.c | 48 ++++++++++++++++++++++++++++++++++++++-------- fs/xfs/xfs_inode.h | 21 +++++++++++++------- 2 files changed, 54 insertions(+), 15 deletions(-)fs/xfs/xfs_inode.c +22
-1@@ -345,9 +345,43 @@ xfs_ilock_demote( }#if defined(DEBUG ) || defined(XFS_WARN ) -int +static inline bool +__xfs_rwsem_islocked ( +struct rw_semaphore *rwsem, +int lock_flags) +{ +int arg; + +if (!debug_locks) +return rwsem_is_locked (rwsem); + +if (lock_flags & (1 <<XFS_SHARED_LOCK_SHIFT )) { +/* +* The caller could be asking if we have (shared | excl) +* access to the lock. Ask lockdep if the rwsem is +* locked either for read or write access. +* +* The caller could also be asking if we have only +* shared access to the lock. Holding a rwsem +* write-locked implies read access as well, so the +* request to lockdep is the same for this case. +*/ + arg =-1 ;
fs/xfs/xfs_inode.c xfs_ilock_demote( · line 379
Quoted 10 lines
fs/xfs/xfs_inode.c +10
-0+ }else { +/* +* The caller is asking if we have only exclusive access +* to the lock. Ask lockdep if the rwsem is locked for +* write access. +*/ + arg =0 ; + } + +return lockdep_is_held_type (rwsem, arg);
Why not write this as:
if (lock_flags & (1 << XFS_SHARED_LOCK_SHIFT)) {
...
return lockdep_is_held_type(rwsem, 1);
}
...
return lockdep_is_held_type(rwsem, 0);
}which seems a lot easier to read compare to the strange arg variable.
Otherwise this looks good to me:
PATCH v11 2/4 xfs: clean up whitespace in xfs_isilocked() calls
In reply to Pavel ReichlMake whitespace follow the same pattern in all xfs_isilocked() calls.
--- fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/xfs_file.c | 3 ++- fs/xfs/xfs_inode.c | 4 ++-- fs/xfs/xfs_qm.c | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +1 -1
@@ -3883,7 +3883,7 @@ xfs_bmapi_read(ASSERT (*nmap >=1 );ASSERT (!(flags & ~(XFS_BMAPI_ATTRFORK |XFS_BMAPI_ENTIRE ))); -ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL ));if (WARN_ON_ONCE (!ifp))return -EFSCORRUPTED ;
fs/xfs/xfs_file.c +2 -1
@@ -763,7 +763,8 @@ xfs_break_layouts(bool retry;int error; -ASSERT (xfs_isilocked (XFS_I (inode),XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (XFS_I (inode), +XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )); do { retry = false;
fs/xfs/xfs_inode.c +2 -2
@@ -2781,7 +2781,7 @@ static voidxfs_iunpin ( struct xfs_inode *ip) { -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));trace_xfs_inode_unpin_nowait (ip, _RET_IP_);
@@ -3474,7 +3474,7 @@ xfs_iflush(struct xfs_mount *mp = ip->i_mount;int error; -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));ASSERT (xfs_isiflocked (ip));ASSERT (ip->i_df.if_format !=XFS_DINODE_FMT_BTREE || ip->i_df.if_nextents >XFS_IFORK_MAXEXT (ip,XFS_DATA_FORK ));
fs/xfs/xfs_qm.c +1 -1
@@ -1803,7 +1803,7 @@ xfs_qm_vop_chown_reserve(int error; -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));ASSERT (XFS_IS_QUOTA_RUNNING (mp)); delblks = ip->i_delayed_blks;
Signature · 1 line
2.26.2
Re: [PATCH v11 2/4] xfs: clean up whitespace in xfs_isilocked() calls
Quoted 5 lines · Pavel Reichl
Make whitespace follow the same pattern in all
xfs_isilocked()calls.Signed-off-by Pavel Reichl <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>---
Quoted 71 lines
fs/xfs/libxfs/xfs_bmap.c | 2 +- fs/xfs/xfs_file.c | 3 ++- fs/xfs/xfs_inode.c | 4 ++-- fs/xfs/xfs_qm.c | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-)fs/xfs/libxfs/xfs_bmap.c +1
-1@@ -3883,7 +3883,7 @@ xfs_bmapi_read(ASSERT (*nmap >=1 );ASSERT (!(flags & ~(XFS_BMAPI_ATTRFORK |XFS_BMAPI_ENTIRE ))); -ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_SHARED |XFS_ILOCK_EXCL ));if (WARN_ON_ONCE (!ifp))return -EFSCORRUPTED ;fs/xfs/xfs_file.c +2
-1@@ -763,7 +763,8 @@ xfs_break_layouts(bool retry;int error; -ASSERT (xfs_isilocked (XFS_I (inode),XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (XFS_I (inode), +XFS_IOLOCK_SHARED |XFS_IOLOCK_EXCL )); do { retry = false;fs/xfs/xfs_inode.c +2
-2@@ -2781,7 +2781,7 @@ static voidxfs_iunpin ( struct xfs_inode *ip) { -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));trace_xfs_inode_unpin_nowait (ip, _RET_IP_);@@ -3474,7 +3474,7 @@ xfs_iflush(struct xfs_mount *mp = ip->i_mount;int error; -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));ASSERT (xfs_isiflocked (ip));ASSERT (ip->i_df.if_format !=XFS_DINODE_FMT_BTREE || ip->i_df.if_nextents >XFS_IFORK_MAXEXT (ip,XFS_DATA_FORK ));fs/xfs/xfs_qm.c +1
-1@@ -1803,7 +1803,7 @@ xfs_qm_vop_chown_reserve(int error; -ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ));ASSERT (XFS_IS_QUOTA_RUNNING (mp)); delblks = ip->i_delayed_blks;Signature · 1 line
2.26.2
Re: [PATCH v11 2/4] xfs: clean up whitespace in xfs_isilocked() calls
In reply to Pavel ReichlLooks good,
PATCH v11 3/4 xfs: xfs_isilocked() can only check a single lock type
In reply to Pavel ReichlIn its current form, xfs_isilocked() is only able to test one lock type at a time - ilock, iolock, or mmap lock, but combinations are not properly handled. The intent here is to check that both XFS_IOLOCK_EXCL and XFS_ILOCK_EXCL are held, so test them each separately.
The commit ecfea3f0c8c6 ("xfs: split xfs_bmap_shift_extents") ORed the flags together which was an error, so this patch reverts that part of the change and check the locks independently.
--- fs/xfs/libxfs/xfs_bmap.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +4 -2
@@ -5787,7 +5787,8 @@ xfs_bmap_collapse_extents(if (XFS_FORCED_SHUTDOWN (mp))return -EIO ; -ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));if (!(ifp->if_flags &XFS_IFEXTENTS )) { error =xfs_iread_extents (tp, ip, whichfork);
@@ -5904,7 +5905,8 @@ xfs_bmap_insert_extents(if (XFS_FORCED_SHUTDOWN (mp))return -EIO ; -ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));if (!(ifp->if_flags &XFS_IFEXTENTS )) { error =xfs_iread_extents (tp, ip, whichfork);
Signature · 1 line
2.26.2
Re: [PATCH v11 3/4] xfs: xfs_isilocked() can only check a single lock type
Quoted 9 lines · Pavel Reichl
In its current form,
xfs_isilocked()is only able to test one lock type at a time - ilock, iolock, or mmap lock, but combinations are not properly handled. The intent here is to check that bothXFS_IOLOCK_EXCLandXFS_ILOCK_EXCLare held, so test them each separately.The commit
ecfea3f0c8c6("xfs: splitxfs_bmap_shift_extents") ORed the flags together which was an error, so this patch reverts that part of the change and check the locks independently.
Quoted 6 lines
Fixes ecfea3f0c8c6 ("xfs: split xfs_bmap_shift_extents")Suggested-by Dave Chinner <[email protected]>Signed-off-by Pavel Reichl <[email protected]>Reviewed-by Darrick J. Wong <[email protected]>---
Quoted 30 lines
fs/xfs/libxfs/xfs_bmap.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)fs/xfs/libxfs/xfs_bmap.c +4
-2@@ -5787,7 +5787,8 @@ xfs_bmap_collapse_extents(if (XFS_FORCED_SHUTDOWN (mp))return -EIO ; -ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));if (!(ifp->if_flags &XFS_IFEXTENTS )) { error =xfs_iread_extents (tp, ip, whichfork);@@ -5904,7 +5905,8 @@ xfs_bmap_insert_extents(if (XFS_FORCED_SHUTDOWN (mp))return -EIO ; -ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL |XFS_ILOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_IOLOCK_EXCL )); +ASSERT (xfs_isilocked (ip,XFS_ILOCK_EXCL ));if (!(ifp->if_flags &XFS_IFEXTENTS )) { error =xfs_iread_extents (tp, ip, whichfork);Signature · 1 line
2.26.2
Re: [PATCH v11 3/4] xfs: xfs_isilocked() can only check a single lock type
In reply to Pavel ReichlLooks good,
PATCH v11 4/4 xfs: replace mrlock_t with rw_semaphores
In reply to Pavel ReichlRemove mrlock_t as it does not provide any extra value over rw_semaphores. Make i_lock and i_mmaplock native rw_semaphores and replace mr*() functions with native rwsem calls.
Release the lock in xfs_btree_split() just before the work-queue executing xfs_btree_split_worker() is scheduled and make xfs_btree_split_worker() to acquire the lock as a first thing and release it just before returning from the function. This it done so the ownership of the lock is transfered between kernel threads and thus lockdep won't complain about lock being held by a different kernel thread.
--- fs/xfs/libxfs/xfs_btree.c | 24 ++++++++++++ fs/xfs/mrlock.h | 78 --------------------------------------- fs/xfs/xfs_inode.c | 50 +++++++++++++------------ fs/xfs/xfs_inode.h | 4 +- fs/xfs/xfs_iops.c | 4 +- fs/xfs/xfs_linux.h | 2 +- fs/xfs/xfs_super.c | 6 +-- 7 files changed, 57 insertions(+), 111 deletions(-) delete mode 100644 fs/xfs/mrlock.h
fs/xfs/libxfs/xfs_btree.c +24 -0
@@ -2816,6 +2816,12 @@ xfs_btree_split_worker(unsigned long pflags;unsigned long new_pflags =PF_MEMALLOC_NOFS ; +/* +* Update lockdep's lock ownership information to point to +* this thread as the thread that scheduled this worker is waiting +* for its completion. +*/ +rwsem_acquire (&args->cur->bc_ino.ip->i_lock.dep_map,0 ,0 , _RET_IP_);/* * we are in a transaction context here, but may also be doing work * in kswapd context, and hence we may need to inherit that state
@@ -2829,6 +2835,12 @@ xfs_btree_split_worker( args->result =__xfs_btree_split (args->cur, args->level, args->ptrp, args->key, args->curp, args->stat); +/* +* Update lockdep's lock ownership information to reflect that we will +* be transferring the ilock from this worker back to the scheduling +* thread. +*/ +rwsem_release (&args->cur->bc_ino.ip->i_lock.dep_map, _THIS_IP_);complete (args->done);current_restore_flags_nested (&pflags, new_pflags);
@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/ +rwsem_release (&cur->bc_ino.ip->i_lock.dep_map, _THIS_IP_);queue_work (xfs_alloc_wq, &args.work);wait_for_completion (&done); +/* +* Update lockdep's lock ownership information to point to +* this thread as the lock owner now that the worker item is +* done. +*/ +rwsem_acquire (&cur->bc_ino.ip->i_lock.dep_map,0 ,0 , _RET_IP_);destroy_work_on_stack (&args.work);return args.result; }
fs/xfs/mrlock.h deleted +0 -78
78 lines not on this page · raw message
fs/xfs/xfs_inode.c +26 -24
106 lines not on this page · raw message
fs/xfs/xfs_inode.h +2 -2
@@ -39,8 +39,8 @@ typedef struct xfs_inode {/* Transaction and locking information. */ struct xfs_inode_log_item *i_itemp;/* logging information */ -mrlock_t i_lock;/* inode lock */ -mrlock_t i_mmaplock;/* inode mmap IO lock */ +struct rw_semaphore i_lock;/* inode lock */ +struct rw_semaphore i_mmaplock;/* inode mmap IO lock */ atomic_t i_pincount;/* inode pin count */ /*
fs/xfs/xfs_iops.c +2 -2
@@ -1336,9 +1336,9 @@ xfs_setup_inode(*/ lockdep_set_class (&inode->i_rwsem, &inode->i_sb->s_type->i_mutex_dir_key); -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_dir_ilock_class); +lockdep_set_class (&ip->i_lock, &xfs_dir_ilock_class); }else { -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_nondir_ilock_class); +lockdep_set_class (&ip->i_lock, &xfs_nondir_ilock_class); }/*
fs/xfs/xfs_linux.h +1 -1
@@ -22,7 +22,6 @@ typedef __u32 xfs_nlink_t;#include "xfs_types.h" #include "kmem.h" -#include "mrlock.h" #include <linux/semaphore.h> #include <linux/mm.h>
@@ -61,6 +60,7 @@ typedef __u32 xfs_nlink_t;#include <linux/ratelimit.h> #include <linux/rhashtable.h> #include <linux/xattr.h> +#include <linux/rwsem.h> #include <asm/page.h> #include <asm/div64.h>
fs/xfs/xfs_super.c +2 -4
@@ -708,10 +708,8 @@ xfs_fs_inode_init_once(atomic_set (&ip->i_pincount,0 );spin_lock_init (&ip->i_flags_lock); -mrlock_init (&ip->i_mmaplock,MRLOCK_ALLOW_EQUAL_PRI |MRLOCK_BARRIER , -"xfsino" , ip->i_ino); -mrlock_init (&ip->i_lock,MRLOCK_ALLOW_EQUAL_PRI |MRLOCK_BARRIER , -"xfsino" , ip->i_ino); +init_rwsem (&ip->i_mmaplock); +init_rwsem (&ip->i_lock); }/*
Signature · 1 line
2.26.2
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 28 lines · Pavel Reichl
Remove
mrlock_tas it does not provide any extra value overrw_semaphores. Makei_lockandi_mmaplocknativerw_semaphoresand replace mr*() functions with native rwsem calls.Release the lock in
xfs_btree_split()just before the work-queue executingxfs_btree_split_worker()is scheduled and makexfs_btree_split_worker()to acquire the lock as a first thing and release it just before returning from the function. This it done so the ownership of the lock is transfered between kernel threads and thus lockdep won't complain about lock being held by a different kernel thread.Signed-off-by Pavel Reichl <[email protected]>--- fs/xfs/libxfs/xfs_btree.c | 24 ++++++++++++ fs/xfs/mrlock.h | 78 --------------------------------------- fs/xfs/xfs_inode.c | 50 +++++++++++++------------ fs/xfs/xfs_inode.h | 4 +- fs/xfs/xfs_iops.c | 4 +- fs/xfs/xfs_linux.h | 2 +- fs/xfs/xfs_super.c | 6 +-- 7 files changed, 57 insertions(+), 111 deletions(-) delete mode 100644 fs/xfs/mrlock.hfs/xfs/libxfs/xfs_btree.c +0
-0
...
fs/xfs/libxfs/xfs_btree.c xfs_btree_split( · line 2882
Quoted 9 lines
fs/xfs/libxfs/xfs_btree.c +5
-0@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/
Can we update this comment to explain why we need to do this? E.g., I'm assuming there's a lockdep splat somewhere down in the split worker without it, but it's not immediately clear where and so it might not be obvious if we're ever able to remove this.
Quoted 12 lines
fs/xfs/libxfs/xfs_btree.c +7
-0+rwsem_release (&cur->bc_ino.ip->i_lock.dep_map, _THIS_IP_);queue_work (xfs_alloc_wq, &args.work);wait_for_completion (&done); +/* +* Update lockdep's lock ownership information to point to +* this thread as the lock owner now that the worker item is +* done. +*/ +rwsem_acquire (&cur->bc_ino.ip->i_lock.dep_map,0 ,0 , _RET_IP_);destroy_work_on_stack (&args.work);return args.result; }
...
Quoted 4 lines
fs/xfs/xfs_inode.c +0
-0
...
Quoted 16 lines
fs/xfs/xfs_inode.c +4
-6@@ -384,16 +385,17 @@ xfs_isilocked( struct xfs_inode *ip, uint lock_flags) { -if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { -if (!(lock_flags &XFS_ILOCK_SHARED )) -return !!ip->i_lock.mr_writer; -return rwsem_is_locked (&ip->i_lock.mr_lock); +if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { +ASSERT (!(lock_flags & ~(XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_lock, + (lock_flags >>XFS_ILOCK_FLAG_SHIFT )); } -if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { -if (!(lock_flags &XFS_MMAPLOCK_SHARED ))
fs/xfs/xfs_inode.c xfs_isilocked( · line 401
Quoted 10 lines
fs/xfs/xfs_inode.c +5
-2-return !!ip->i_mmaplock.mr_writer; -return rwsem_is_locked (&ip->i_mmaplock.mr_lock); +if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { +ASSERT (!(lock_flags & + ~(XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_mmaplock, + (lock_flags >>XFS_MMAPLOCK_FLAG_SHIFT )); }if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) {
Can we add a similar assert for this case as we have for the others? Otherwise the rest looks fairly straightforward to me.
Brian
Quoted 71 lines
fs/xfs/xfs_inode.h +2
-2@@ -39,8 +39,8 @@ typedef struct xfs_inode {/* Transaction and locking information. */ struct xfs_inode_log_item *i_itemp;/* logging information */ -mrlock_t i_lock;/* inode lock */ -mrlock_t i_mmaplock;/* inode mmap IO lock */ +struct rw_semaphore i_lock;/* inode lock */ +struct rw_semaphore i_mmaplock;/* inode mmap IO lock */ atomic_t i_pincount;/* inode pin count */ /* fs/xfs/xfs_iops.c +2
-2@@ -1336,9 +1336,9 @@ xfs_setup_inode(*/ lockdep_set_class (&inode->i_rwsem, &inode->i_sb->s_type->i_mutex_dir_key); -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_dir_ilock_class); +lockdep_set_class (&ip->i_lock, &xfs_dir_ilock_class); }else { -lockdep_set_class (&ip->i_lock.mr_lock, &xfs_nondir_ilock_class); +lockdep_set_class (&ip->i_lock, &xfs_nondir_ilock_class); }/* fs/xfs/xfs_linux.h +1
-1@@ -22,7 +22,6 @@ typedef __u32 xfs_nlink_t;#include "xfs_types.h" #include "kmem.h" -#include "mrlock.h" #include <linux/semaphore.h> #include <linux/mm.h> @@ -61,6 +60,7 @@ typedef __u32 xfs_nlink_t;#include <linux/ratelimit.h> #include <linux/rhashtable.h> #include <linux/xattr.h> +#include <linux/rwsem.h> #include <asm/page.h> #include <asm/div64.h> fs/xfs/xfs_super.c +2
-4@@ -708,10 +708,8 @@ xfs_fs_inode_init_once(atomic_set (&ip->i_pincount,0 );spin_lock_init (&ip->i_flags_lock); -mrlock_init (&ip->i_mmaplock,MRLOCK_ALLOW_EQUAL_PRI |MRLOCK_BARRIER , -"xfsino" , ip->i_ino); -mrlock_init (&ip->i_lock,MRLOCK_ALLOW_EQUAL_PRI |MRLOCK_BARRIER , -"xfsino" , ip->i_ino); +init_rwsem (&ip->i_mmaplock); +init_rwsem (&ip->i_lock); }/* Signature · 1 line
2.26.2
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 15 lines · Brian Foster
...
fs/xfs/libxfs/xfs_btree.c xfs_btree_split( · line 2882
Quoted 9 lines
fs/xfs/libxfs/xfs_btree.c +5
-0@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/ Can we update this comment to explain why we need to do this? E.g., I'm assuming there's a lockdep splat somewhere down in the split worker without it, but it's not immediately clear where and so it might not be obvious if we're ever able to remove this.
Hi, would something like this work for you?
/*
+ * Update lockdep's ownership information to reflect that we
+ * will be transferring the ilock from this thread to the
+ * worker (xfs_btree_split_worker() run via queue_work()).
+ * If the ownership transfer would not happen lockdep would
+ * assert in the worker thread because the ilock would be owned
+ * by the original thread.
+ */
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 23 lines · Pavel Reichl
Quoted 15 lines · Brian Foster
...
fs/xfs/libxfs/xfs_btree.c xfs_btree_split( · line 2882
Quoted 9 lines
fs/xfs/libxfs/xfs_btree.c +5
-0@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/ Can we update this comment to explain why we need to do this? E.g., I'm assuming there's a lockdep splat somewhere down in the split worker without it, but it's not immediately clear where and so it might not be obvious if we're ever able to remove this.
Hi, would something like this work for you?
/*
Review
Quoted 7 lines
(quoted diff) +7
-0+ * Update lockdep's ownership information to reflect that we + * will be transferring the ilock from this thread to the + * worker (xfs_btree_split_worker() run via queue_work()). + * If the ownership transfer would not happen lockdep would + * assert in the worker thread because the ilock would be owned + * by the original thread. + */
That doesn't really answer the question. Do you have a record of the lockdep error message that occurs without this state transfer, by chance?
Brian
Quoted 1 line
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 36 lines · Brian Foster
Quoted 23 lines · Pavel Reichl
Quoted 15 lines · Brian Foster
...
fs/xfs/libxfs/xfs_btree.c xfs_btree_split( · line 2882
Quoted 9 lines
fs/xfs/libxfs/xfs_btree.c +5
-0@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/ Can we update this comment to explain why we need to do this? E.g., I'm assuming there's a lockdep splat somewhere down in the split worker without it, but it's not immediately clear where and so it might not be obvious if we're ever able to remove this.
Hi, would something like this work for you?
/*Review
Quoted 7 lines
(quoted diff) +7
-0+ * Update lockdep's ownership information to reflect that we + * will be transferring the ilock from this thread to the + * worker (xfs_btree_split_worker() run via queue_work()). + * If the ownership transfer would not happen lockdep would + * assert in the worker thread because the ilock would be owned + * by the original thread. + */That doesn't really answer the question. Do you have a record of the lockdep error message that occurs without this state transfer, by chance?
Quoted 1 line
Brian
Hi, please see this mail from Darrick - he hit the issue first - http://mail.spinics.net/lists/linux-xfs/msg38967.html
Quoted 3 lines
Quoted 2 lines
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 39 lines · Pavel Reichl
Quoted 36 lines · Brian Foster
Quoted 23 lines · Pavel Reichl
Quoted 15 lines · Brian Foster
...
fs/xfs/libxfs/xfs_btree.c xfs_btree_split( · line 2882
Quoted 9 lines
fs/xfs/libxfs/xfs_btree.c +5
-0@@ -2863,8 +2875,20 @@ xfs_btree_split( args.done = &done; args.kswapd =current_is_kswapd ();INIT_WORK_ONSTACK (&args.work, xfs_btree_split_worker); +/* +* Update lockdep's ownership information to reflect that we +* will be transferring the ilock from this thread to the +* worker. +*/ Can we update this comment to explain why we need to do this? E.g., I'm assuming there's a lockdep splat somewhere down in the split worker without it, but it's not immediately clear where and so it might not be obvious if we're ever able to remove this.
Hi, would something like this work for you?
/*Review
Quoted 7 lines
(quoted diff) +7
-0+ * Update lockdep's ownership information to reflect that we + * will be transferring the ilock from this thread to the + * worker (xfs_btree_split_worker() run via queue_work()). + * If the ownership transfer would not happen lockdep would + * assert in the worker thread because the ilock would be owned + * by the original thread. + */That doesn't really answer the question. Do you have a record of the lockdep error message that occurs without this state transfer, by chance?
Quoted 4 lines
Quoted 1 line
Brian
Hi, please see this mail from Darrick - he hit the issue first - http://mail.spinics.net/lists/linux-xfs/msg38967.html
Ah, I see.. thanks. I was thinking there was some kind of lock imbalance warning or something, but in reality I think something like the following is sufficient:
"Update lockdep's ownership information to reflect transfer of the ilock from the current task to the worker. Otherwise assertions that the lock is held (such as when logging the inode) might fail due to incorrect task owner state."
Brian
Quoted 4 lines
Quoted 3 lines
Quoted 2 lines
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
In reply to Brian FosterQuoted 27 lines
...
Quoted 25 lines
fs/xfs/xfs_inode.c +9
-8@@ -384,16 +385,17 @@ xfs_isilocked( struct xfs_inode *ip, uint lock_flags) { -if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { -if (!(lock_flags &XFS_ILOCK_SHARED )) -return !!ip->i_lock.mr_writer; -return rwsem_is_locked (&ip->i_lock.mr_lock); +if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { +ASSERT (!(lock_flags & ~(XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_lock, + (lock_flags >>XFS_ILOCK_FLAG_SHIFT )); } -if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { -if (!(lock_flags &XFS_MMAPLOCK_SHARED )) -return !!ip->i_mmaplock.mr_writer; -return rwsem_is_locked (&ip->i_mmaplock.mr_lock); +if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { +ASSERT (!(lock_flags & + ~(XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_mmaplock, + (lock_flags >>XFS_MMAPLOCK_FLAG_SHIFT )); }
Quoted 5 lines
fs/xfs/xfs_inode.c xfs_isilocked( · line 401
Quoted 1 line
fs/xfs/xfs_inode.c +0
-0if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) {Can we add a similar assert for this case as we have for the others? Otherwise the rest looks fairly straightforward to me.
Sure we can! But do we want to?
I think that these asserts are supposed to make sure that only flags for one of the inode's locks are used eg. ILOCK, MMAPLOCK or IOLOCK but no combination! So if we reach this 3rd condition we already know that the flags for ILOCK and MMAPLOCK were not set. However if there's possibility for more locks to be added in the future or just for the 'code symmetry' purposes - I have no problem to update the code.
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
Quoted 33 lines · Pavel Reichl
Quoted 27 lines
...
Quoted 25 lines
fs/xfs/xfs_inode.c +9
-8@@ -384,16 +385,17 @@ xfs_isilocked( struct xfs_inode *ip, uint lock_flags) { -if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { -if (!(lock_flags &XFS_ILOCK_SHARED )) -return !!ip->i_lock.mr_writer; -return rwsem_is_locked (&ip->i_lock.mr_lock); +if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { +ASSERT (!(lock_flags & ~(XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_lock, + (lock_flags >>XFS_ILOCK_FLAG_SHIFT )); } -if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { -if (!(lock_flags &XFS_MMAPLOCK_SHARED )) -return !!ip->i_mmaplock.mr_writer; -return rwsem_is_locked (&ip->i_mmaplock.mr_lock); +if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { +ASSERT (!(lock_flags & + ~(XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_mmaplock, + (lock_flags >>XFS_MMAPLOCK_FLAG_SHIFT )); }Quoted 5 lines
fs/xfs/xfs_inode.c xfs_isilocked( · line 401
Quoted 1 line
fs/xfs/xfs_inode.c +0
-0if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) {Can we add a similar assert for this case as we have for the others? Otherwise the rest looks fairly straightforward to me.
Quoted 8 lines
Sure we can! But do we want to?
I think that these asserts are supposed to make sure that only flags for one of the inode's locks are used eg. ILOCK, MMAPLOCK or IOLOCK but no combination! So if we reach this 3rd condition we already know that the flags for ILOCK and MMAPLOCK were not set. However if there's possibility for more locks to be added in the future or just for the 'code symmetry' purposes - I have no problem to update the code.
It's generally a good idea not to leave logic bombs of the sort where where the debugging code can bitrot into incorrectness if someone unwittingly adds another level of locking later.
(That said, I really hope we don't; I already consider it a little strange to have separate io and mmap locks...)
--D
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
In reply to Pavel ReichlQuoted 33 lines · Pavel Reichl
Quoted 27 lines
...
Quoted 25 lines
fs/xfs/xfs_inode.c +9
-8@@ -384,16 +385,17 @@ xfs_isilocked( struct xfs_inode *ip, uint lock_flags) { -if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { -if (!(lock_flags &XFS_ILOCK_SHARED )) -return !!ip->i_lock.mr_writer; -return rwsem_is_locked (&ip->i_lock.mr_lock); +if (lock_flags & (XFS_ILOCK_EXCL |XFS_ILOCK_SHARED )) { +ASSERT (!(lock_flags & ~(XFS_ILOCK_EXCL |XFS_ILOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_lock, + (lock_flags >>XFS_ILOCK_FLAG_SHIFT )); } -if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { -if (!(lock_flags &XFS_MMAPLOCK_SHARED )) -return !!ip->i_mmaplock.mr_writer; -return rwsem_is_locked (&ip->i_mmaplock.mr_lock); +if (lock_flags & (XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED )) { +ASSERT (!(lock_flags & + ~(XFS_MMAPLOCK_EXCL |XFS_MMAPLOCK_SHARED ))); +return __xfs_rwsem_islocked (&ip->i_mmaplock, + (lock_flags >>XFS_MMAPLOCK_FLAG_SHIFT )); }Quoted 5 lines
fs/xfs/xfs_inode.c xfs_isilocked( · line 401
Quoted 1 line
fs/xfs/xfs_inode.c +0
-0if (lock_flags & (XFS_IOLOCK_EXCL |XFS_IOLOCK_SHARED )) {Can we add a similar assert for this case as we have for the others? Otherwise the rest looks fairly straightforward to me.
Quoted 5 lines
Sure we can! But do we want to?
I think that these asserts are supposed to make sure that only flags for one of the inode's locks are used eg. ILOCK, MMAPLOCK or IOLOCK but no combination! So if we reach this 3rd condition we already know that the flags for ILOCK and MMAPLOCK were not set. However if there's possibility for more locks to be added in the future or just for the 'code symmetry' purposes - I have no problem to update the code.
Fair point. I do tend to agree with Darrick that I'd rather not rely on even mildly tricky/subtle logic to optimize away things like asserts (that are already optimized away on production kernels). Somebody could come along, refactor this function and very easily gloss over the fact that particular checks are missing. That said, I suppose it's technically dead code with the current logic so it's not that big of a deal IMO.
Brian
Re: [PATCH v11 4/4] xfs: replace mrlock_t with rw_semaphores
In reply to Pavel ReichlLooks good,