locking/mutex: Set and clear owner using WRITE_ONCE()
PATCH v2 1/1 locking/mutex: Set and clear owner using WRITE_ONCE()
The mutex owner can get read and written to locklessly. Use WRITE_ONCE when setting and clearing the owner field in order to avoid optimizations such as store tearing. This avoids situations where the owner field gets written to with multiple stores and another thread could concurrently read and use a partially written owner value.
Signed-off-by Jason Low <[email protected]>
Acked-by Davidlohr Bueso <[email protected]>
--- kernel/locking/mutex-debug.h | 4 ++-- kernel/locking/mutex.h | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-)
kernel/locking/mutex-debug.h +2 -2
@@ -29,12 +29,12 @@ extern void debug_mutex_init(struct mutex *lock, const char *name,static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current; +WRITE_ONCE (lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#define spin_lock_mutex (lock, flags) \
kernel/locking/mutex.h +8 -2
@@ -17,14 +17,20 @@ __list_del((waiter)->list.prev, (waiter)->list.next)#ifdef CONFIG_MUTEX_SPIN_ON_OWNER +/* +* The mutex owner can get read and written to locklessly. +* We should use WRITE_ONCE when writing the owner value to +* avoid store tearing, otherwise, a thread could potentially +* read a partially written and incomplete owner value. +*/ static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current; +WRITE_ONCE (lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#else static inline void mutex_set_owner (struct mutex *lock)
Signature · 1 line
2.1.4
Quoted 50 lines · Jason Low
The mutex owner can get read and written to locklessly. Use
WRITE_ONCEwhen setting and clearing the owner field in order to avoid optimizations such as store tearing. This avoids situations where the owner field gets written to with multiple stores and another thread could concurrently read and use a partially written owner value.Signed-off-by Jason Low<[email protected]>Acked-by Davidlohr Bueso<[email protected]>--- kernel/locking/mutex-debug.h | 4 ++-- kernel/locking/mutex.h | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-)kernel/locking/mutex-debug.h +2
-2@@ -29,12 +29,12 @@ extern void debug_mutex_init(struct mutex *lock, const char *name,static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current; +WRITE_ONCE (lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#define spin_lock_mutex (lock, flags) \kernel/locking/mutex.h +6
-1@@ -17,14 +17,20 @@ __list_del((waiter)->list.prev, (waiter)->list.next)#ifdef CONFIG_MUTEX_SPIN_ON_OWNER +/* +* The mutex owner can get read and written to locklessly. +* We should use WRITE_ONCE when writing the owner value to +* avoid store tearing, otherwise, a thread could potentially +* read a partially written and incomplete owner value. +*/ static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current;
kernel/locking/mutex.h line 36
Quoted 10 lines
kernel/locking/mutex.h +2
-1+ WRITE_ONCE(lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#else static inline void mutex_set_owner (struct mutex *lock)
Acked-by Waiman Long <[email protected]>
tip-bot for Jason Low
merge botlocking/mutex: Set and clear owner using WRITE_ONCE()
Commit-ID: 6e2814745c67ab422b86262b05e6f23a56f28aa3 Gitweb: http://git.kernel.org/tip/6e2814745c67ab422b86262b05e6f23a56f28aa3 Author: Jason Low <[email protected]> AuthorDate: Fri, 20 May 2016 15:19:36 -0700 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 3 Jun 2016 12:06:10 +0200
locking/mutex: Set and clear owner using WRITE_ONCE()
The mutex owner can get read and written to locklessly. Use WRITE_ONCE when setting and clearing the owner field in order to avoid optimizations such as store tearing. This avoids situations where the owner field gets written to with multiple stores and another thread could concurrently read and use a partially written owner value.
Signed-off-by Jason Low <[email protected]>
Signed-off-by Peter Zijlstra (Intel) <[email protected]>
Acked-by Davidlohr Bueso <[email protected]>
Acked-by Waiman Long <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Linus Torvalds <[email protected]>
Cc Paul E. McKenney <[email protected]>
Cc Peter Zijlstra <[email protected]>
Cc Scott J Norton <[email protected]>
Cc Terry Rudd <[email protected]>
Cc Thomas Gleixner <[email protected]>
Signed-off-by Ingo Molnar <[email protected]>
--- kernel/locking/mutex-debug.h | 4 ++-- kernel/locking/mutex.h | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-)
kernel/locking/mutex-debug.h +2 -2
@@ -29,12 +29,12 @@ extern void debug_mutex_init(struct mutex *lock, const char *name,static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current; +WRITE_ONCE (lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#define spin_lock_mutex (lock, flags) \
kernel/locking/mutex.h +8 -2
@@ -17,14 +17,20 @@ __list_del((waiter)->list.prev, (waiter)->list.next)#ifdef CONFIG_MUTEX_SPIN_ON_OWNER +/* +* The mutex owner can get read and written to locklessly. +* We should use WRITE_ONCE when writing the owner value to +* avoid store tearing, otherwise, a thread could potentially +* read a partially written and incomplete owner value. +*/ static inline void mutex_set_owner (struct mutex *lock) { - lock->owner = current; +WRITE_ONCE (lock->owner, current); }static inline void mutex_clear_owner (struct mutex *lock) { - lock->owner =NULL ; +WRITE_ONCE (lock->owner,NULL ); }#else static inline void mutex_set_owner (struct mutex *lock)