perpcu rwsem, fs/locks and killing lglocks
Subsystems (5)
Peter Zijlstra
maintainercover perpcu rwsem, fs/locks and killing lglocks
Hi all,
Here are some patches that I've been sitting on for far too long now.
They're a respin of earlier work [1], and have been verified by Daniel Wagner to not suffer the regression he measured with the previous set (part of which was operator error).
Patches 4 and 5 were needed to solve a (smallish) performance regression on CONFIG_PREEMPT=y. They avoid a number of preemption points (and code).
I was going to gather pretty numbers from Daniels data, but I keep putting that off and figured I ought to send the patches already.
[1] https://lkml.kernel.org/r/[email protected]
--- Documentation/locking/lglock.txt | 166 --------------------------------------- fs/Kconfig | 1 + fs/locks.c | 68 +++++++++++----- include/linux/lglock.h | 81 ------------------- include/linux/percpu-rwsem.h | 36 +++++++-- kernel/locking/Makefile | 1 - kernel/locking/lglock.c | 111 -------------------------- kernel/stop_machine.c | 42 ++++++---- 8 files changed, 107 insertions(+), 399 deletions(-)
Peter Zijlstra
maintainerPATCH 1/7 percpu-rwsem: DEFINE_STATIC_PERCPU_RWSEM
Provide a static init.
--- include/linux/percpu-rwsem.h | 12 ++++++++++++ 1 file changed, 12 insertions(+)
include/linux/percpu-rwsem.h +12 -0
@@ -16,6 +16,15 @@ struct percpu_rw_semaphore {int readers_block; }; +#define DEFINE_STATIC_PERCPU_RWSEM (name) \ +static DEFINE_PER_CPU(unsigned int, __percpu_rwsem_rc_##name); \ +static struct percpu_rw_semaphore name = { \ + .rss = __RCU_SYNC_INITIALIZER(name.rss, RCU_SCHED_SYNC), \ + .read_count = &__percpu_rwsem_rc_##name, \ + .rw_sem = __RWSEM_INITIALIZER(name.rw_sem), \ + .writer = __WAIT_QUEUE_HEAD_INITIALIZER(name.writer), \ +} +extern int __percpu_down_read (struct percpu_rw_semaphore *,int );extern void __percpu_up_read (struct percpu_rw_semaphore *);
@@ -102,6 +111,9 @@ extern void percpu_free_rwsem(struct per#define percpu_rwsem_is_held (sem) lockdep_is_held(&(sem)->rw_sem) +#define percpu_rwsem_assert_held (sem) \ + lockdep_assert_held(&(sem)->rw_sem) +static inline void percpu_rwsem_release (struct percpu_rw_semaphore *sem,bool read,unsigned long ip) {
Peter Zijlstra
maintainerPATCH 2/7 fs/locks: Replace lg_global with a percpu-rwsem
In reply to Peter ZijlstraReplace the global part of the lglock with a percpu-rwsem.
Since fcl_lock is a spinlock and itself nests under i_lock, which too is a spinlock we cannot acquire sleeping locks at locks_{insert,remove}_global_locks().
We can however wrap all fcl_lock acquisitions with percpu_down_read such that all invocations of locks_{insert,remove}_global_locks() have that read lock held.
This allows us to replace the lg_global part of the lglock with the write side of the rwsem.
In the absense of writers, percpu_{down,up}_read() are free of atomic instructions. This further avoids the very long preempt-disable regions caused by lglock on larger machines.
--- fs/locks.c | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
fs/locks.c +21 -0
@@ -164,6 +164,7 @@ int lease_break_time = 45;*/ DEFINE_STATIC_LGLOCK (file_lock_lglock); static DEFINE_PER_CPU(struct hlist_head, file_lock_list); +DEFINE_STATIC_PERCPU_RWSEM (file_rwsem);/* * The blocked_hash is used to find POSIX lock loops for deadlock detection.
@@ -587,6 +588,8 @@ static int posix_same_owner(struct file_/* Must be called with the flc_lock held! */ static void locks_insert_global_locks (struct file_lock *fl) { +percpu_rwsem_assert_held (&file_rwsem); +lg_local_lock (&file_lock_lglock); fl->fl_link_cpu =smp_processor_id ();hlist_add_head (&fl->fl_link,this_cpu_ptr (&file_lock_list));
@@ -596,6 +599,8 @@ static void locks_insert_global_locks(st/* Must be called with the flc_lock held! */ static void locks_delete_global_locks (struct file_lock *fl) { +percpu_rwsem_assert_held (&file_rwsem); +/* * Avoid taking lock if already unhashed. This is safe since this check * is done while holding the flc_lock, and new insertions into the list
@@ -915,6 +920,7 @@ static int flock_lock_inode(struct inodereturn -ENOMEM ; } +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);if (request->fl_flags &FL_ACCESS ) goto find_conflict;
@@ -955,6 +961,7 @@ static int flock_lock_inode(struct inode out:spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem);if (new_fl)locks_free_lock (new_fl);locks_dispose_list (&dispose);
@@ -991,6 +998,7 @@ static int posix_lock_inode(struct inode new_fl2 =locks_alloc_lock (); } +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);/* * New lock request. Walk all POSIX locks and look for conflicts. If
@@ -1162,6 +1170,7 @@ static int posix_lock_inode(struct inode } out:spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem);/* * Free any unused locks. */
@@ -1436,6 +1445,7 @@ int __break_lease(struct inode *inode, ureturn error; } +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);time_out_leases (inode, &dispose);
@@ -1487,9 +1497,13 @@ int __break_lease(struct inode *inode, ulocks_insert_block (fl, new_fl);trace_break_lease_block (inode, new_fl);spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem); +locks_dispose_list (&dispose); error =wait_event_interruptible_timeout (new_fl->fl_wait, !new_fl->fl_next, break_time); + +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);trace_break_lease_unblock (inode, new_fl);locks_delete_block (new_fl);
@@ -1506,6 +1520,7 @@ int __break_lease(struct inode *inode, u } out:spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem);locks_dispose_list (&dispose);locks_free_lock (new_fl);return error;
@@ -1660,6 +1675,7 @@ generic_add_lease(struct file *filp, lonreturn -EINVAL ; } +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);time_out_leases (inode, &dispose); error =check_conflicting_open (dentry, arg, lease->fl_flags);
@@ -1730,6 +1746,7 @@ generic_add_lease(struct file *filp, lon lease->fl_lmops->lm_setup (lease, priv); out:spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem);locks_dispose_list (&dispose);if (is_deleg)inode_unlock (inode);
@@ -1752,6 +1769,7 @@ static int generic_delete_lease(struct freturn error; } +percpu_down_read (&file_rwsem);spin_lock (&ctx->flc_lock);list_for_each_entry (fl, &ctx->flc_lease, fl_list) { if (fl->fl_file == filp &&
@@ -1764,6 +1782,7 @@ static int generic_delete_lease(struct fif (victim) error = fl->fl_lmops->lm_change (victim,F_UNLCK , &dispose);spin_unlock (&ctx->flc_lock); +percpu_up_read (&file_rwsem);locks_dispose_list (&dispose);return error; }
@@ -2703,6 +2722,7 @@ static void *locks_start(struct seq_filestruct locks_iterator *iter = f->private; iter->li_pos = *pos +1 ; +percpu_down_write (&file_rwsem);lg_global_lock (&file_lock_lglock);spin_lock (&blocked_lock_lock);return seq_hlist_start_percpu (&file_lock_list, &iter->li_cpu, *pos);
@@ -2721,6 +2741,7 @@ static void locks_stop(struct seq_file * {spin_unlock (&blocked_lock_lock);lg_global_unlock (&file_lock_lglock); +percpu_up_write (&file_rwsem); }static const struct seq_operations locks_seq_operations = {
Peter Zijlstra
maintainerPATCH 3/7 fs/locks: Replace lg_local with a per-cpu spinlock
In reply to Peter ZijlstraAs Oleg suggested, replace file_lock_list with a structure containing the hlist head and a spinlock.
This completely removes the lglock from fs/locks.
--- fs/Kconfig | 1 + fs/locks.c | 47 +++++++++++++++++++++++++++++------------------ 2 files changed, 30 insertions(+), 18 deletions(-)
fs/Kconfig +1 -0
@@ -62,6 +62,7 @@ config EXPORTFS config FILE_LOCKING bool "Enable POSIX file locking API" if EXPERT default y + select PERCPU_RWSEM help This option enables standard file locking support, required for filesystems like NFS and for the flock() system
fs/locks.c +29 -18
107 lines not on this page · raw message
Peter Zijlstra
maintainerPATCH 4/7 percpu-rwsem: Add down_read_preempt_disable()
In reply to Peter ZijlstraProvide a down_read()/up_read() variant that keeps preemption disabled over the whole thing, when possible.
This avoids a needless preemption point for constructs such as:
percpu_down_read(&global_rwsem); spin_lock(&lock); ... spin_unlock(&lock); percpu_up_read(&global_rwsem);
Which perturbs timings. In particular it was found to cure a performance regression in a follow up patch in fs/locks.c
--- include/linux/percpu-rwsem.h | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)
include/linux/percpu-rwsem.h +18 -6
@@ -28,7 +28,7 @@ static struct percpu_rw_semaphore name =extern int __percpu_down_read (struct percpu_rw_semaphore *,int );extern void __percpu_up_read (struct percpu_rw_semaphore *); -static inline void percpu_down_read (struct percpu_rw_semaphore *sem) +static inline void percpu_down_read_preempt_disable (struct percpu_rw_semaphore *sem) {might_sleep ();
@@ -46,13 +46,19 @@ static inline void percpu_down_read(stru__this_cpu_inc (*sem->read_count);if (unlikely (!rcu_sync_is_idle (&sem->rss)))__percpu_down_read (sem, false);/* Unconditional memory barrier */ -preempt_enable (); +barrier ();/* -* The barrier() from preempt_enable() prevents the compiler from +* The barrier() prevents the compiler from * bleeding the critical section out. */ } +static inline void percpu_down_read (struct percpu_rw_semaphore *sem) +{ +percpu_down_read_preempt_disable (sem); +preempt_enable (); +} +static inline int percpu_down_read_trylock (struct percpu_rw_semaphore *sem) {int ret =1 ;
@@ -76,13 +82,13 @@ static inline int percpu_down_read_tryloreturn ret; } -static inline void percpu_up_read (struct percpu_rw_semaphore *sem) +static inline void percpu_up_read_preempt_enable (struct percpu_rw_semaphore *sem) {/* -* The barrier() in preempt_disable() prevents the compiler from +* The barrier() prevents the compiler from * bleeding the critical section out. */ -preempt_disable (); +barrier ();/* * Same as in percpu_down_read(). */
@@ -95,6 +101,12 @@ static inline void percpu_up_read(structrwsem_release (&sem->rw_sem.dep_map,1 , _RET_IP_); } +static inline void percpu_up_read (struct percpu_rw_semaphore *sem) +{ +preempt_disable (); +percpu_up_read_preempt_enable (sem); +} +extern void percpu_down_write (struct percpu_rw_semaphore *);extern void percpu_up_write (struct percpu_rw_semaphore *);
Peter Zijlstra
maintainerPATCH 5/7 fs/locks: Use percpu_down_read_preempt_disable
In reply to Peter ZijlstraAvoid spurious preemption by using the percpu_{down,up}_preempt_{dis,en}able() APIs. This reduces things down to a single preemption point at the end of this sequence (in the normal case).
--- fs/locks.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
fs/locks.c +12 -12
@@ -930,7 +930,7 @@ static int flock_lock_inode(struct inodereturn -ENOMEM ; } -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);if (request->fl_flags &FL_ACCESS ) goto find_conflict;
@@ -971,7 +971,7 @@ static int flock_lock_inode(struct inode out:spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);if (new_fl)locks_free_lock (new_fl);locks_dispose_list (&dispose);
@@ -1008,7 +1008,7 @@ static int posix_lock_inode(struct inode new_fl2 =locks_alloc_lock (); } -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);/* * New lock request. Walk all POSIX locks and look for conflicts. If
@@ -1180,7 +1180,7 @@ static int posix_lock_inode(struct inode } out:spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);/* * Free any unused locks. */
@@ -1455,7 +1455,7 @@ int __break_lease(struct inode *inode, ureturn error; } -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);time_out_leases (inode, &dispose);
@@ -1507,13 +1507,13 @@ int __break_lease(struct inode *inode, ulocks_insert_block (fl, new_fl);trace_break_lease_block (inode, new_fl);spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);locks_dispose_list (&dispose); error =wait_event_interruptible_timeout (new_fl->fl_wait, !new_fl->fl_next, break_time); -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);trace_break_lease_unblock (inode, new_fl);locks_delete_block (new_fl);
@@ -1530,7 +1530,7 @@ int __break_lease(struct inode *inode, u } out:spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);locks_dispose_list (&dispose);locks_free_lock (new_fl);return error;
@@ -1685,7 +1685,7 @@ generic_add_lease(struct file *filp, lonreturn -EINVAL ; } -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);time_out_leases (inode, &dispose); error =check_conflicting_open (dentry, arg, lease->fl_flags);
@@ -1756,7 +1756,7 @@ generic_add_lease(struct file *filp, lon lease->fl_lmops->lm_setup (lease, priv); out:spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);locks_dispose_list (&dispose);if (is_deleg)inode_unlock (inode);
@@ -1779,7 +1779,7 @@ static int generic_delete_lease(struct freturn error; } -percpu_down_read (&file_rwsem); +percpu_down_read_preempt_disable (&file_rwsem);spin_lock (&ctx->flc_lock);list_for_each_entry (fl, &ctx->flc_lease, fl_list) { if (fl->fl_file == filp &&
@@ -1792,7 +1792,7 @@ static int generic_delete_lease(struct fif (victim) error = fl->fl_lmops->lm_change (victim,F_UNLCK , &dispose);spin_unlock (&ctx->flc_lock); -percpu_up_read (&file_rwsem); +percpu_up_read_preempt_enable (&file_rwsem);locks_dispose_list (&dispose);return error; }
Peter Zijlstra
maintainerPATCH 6/7 stop_machine: Remove stop_cpus_lock and lg_double_lock/unlock()
In reply to Peter Zijlstrastop_two_cpus() and stop_cpus() use stop_cpus_lock to avoid the deadlock, we need to ensure that the stopper functions can't be queued "backwards" from one another. This doesn't look nice; if we use lglock then we do not really need stopper->lock, cpu_stop_queue_work() could use lg_local_lock() under local_irq_save().
OTOH it would be even better to avoid lglock in stop_machine.c and remove lg_double_lock(). This patch adds "bool stop_cpus_in_progress" set/cleared by queue_stop_cpus_work(), and changes cpu_stop_queue_two_works() to busy wait until it is cleared.
queue_stop_cpus_work() sets stop_cpus_in_progress = T lockless, but after it queues a work on CPU1 it must be visible to stop_two_cpus(CPU1, CPU2) which checks it under the same lock. And since stop_two_cpus() holds the 2nd lock too, queue_stop_cpus_work() can not clear stop_cpus_in_progress if it is also going to queue a work on CPU2, it needs to take that 2nd lock to do this.
--- include/linux/lglock.h | 5 ----- kernel/locking/lglock.c | 22 ---------------------- kernel/stop_machine.c | 42 ++++++++++++++++++++++++++---------------- 3 files changed, 26 insertions(+), 43 deletions(-)
include/linux/lglock.h +0 -5
@@ -52,15 +52,10 @@ struct lglock { static struct lglock name = { .lock = &name ## _lock }void lg_lock_init (struct lglock *lg,char *name); -void lg_local_lock (struct lglock *lg);void lg_local_unlock (struct lglock *lg);void lg_local_lock_cpu (struct lglock *lg,int cpu);void lg_local_unlock_cpu (struct lglock *lg,int cpu); - -void lg_double_lock (struct lglock *lg,int cpu1,int cpu2); -void lg_double_unlock (struct lglock *lg,int cpu1,int cpu2); -void lg_global_lock (struct lglock *lg);void lg_global_unlock (struct lglock *lg);
kernel/locking/lglock.c +0 -22
@@ -60,28 +60,6 @@ void lg_local_unlock_cpu(struct lglock * }EXPORT_SYMBOL (lg_local_unlock_cpu); -void lg_double_lock (struct lglock *lg,int cpu1,int cpu2) -{ -BUG_ON (cpu1 == cpu2); - -/* lock in cpu order, just like lg_global_lock */ -if (cpu2 < cpu1) -swap (cpu1, cpu2); - -preempt_disable (); -lock_acquire_shared (&lg->lock_dep_map,0 ,0 ,NULL , _RET_IP_); -arch_spin_lock (per_cpu_ptr (lg->lock, cpu1)); -arch_spin_lock (per_cpu_ptr (lg->lock, cpu2)); -} - -void lg_double_unlock (struct lglock *lg,int cpu1,int cpu2) -{ -lock_release (&lg->lock_dep_map,1 , _RET_IP_); -arch_spin_unlock (per_cpu_ptr (lg->lock, cpu1)); -arch_spin_unlock (per_cpu_ptr (lg->lock, cpu2)); -preempt_enable (); -} -void lg_global_lock (struct lglock *lg) {int i;
kernel/stop_machine.c +26 -16
91 lines not on this page · raw message
Peter Zijlstra
maintainerPATCH 7/7 locking: Remove lglock
In reply to Peter ZijlstraIt is now unused, remove it before someone else thinks its a good idea to use this.
--- Documentation/locking/lglock.txt | 166 --------------------------------------- include/linux/lglock.h | 76 ----------------- kernel/locking/Makefile | 1 kernel/locking/lglock.c | 89 -------------------- 4 files changed, 332 deletions(-)
Documentation/locking/lglock.txt deleted +0 -166
@@ -1,166 +0,0 @@ -lglock - local/global locks for mostly local access patterns ------------------------------------------------------------- - -Origin: Nick Piggin's VFS scalability series introduced during - 2.6.35++ [1] [2] -Location: kernel/locking/lglock.c - include/linux/lglock.h -Users: currently only the VFS and stop_machine related code - -Design Goal: ------------- - -Improve scalability of globally used large data sets that are -distributed over all CPUs as per_cpu elements. - -To manage global data structures that are partitioned over all CPUs -as per_cpu elements but can be mostly handled by CPU local actions -lglock will be used where the majority of accesses are cpu local -reading and occasional cpu local writing with very infrequent -global write access. - - -* deal with things locally whenever possible - - very fast access to the local per_cpu data - - reasonably fast access to specific per_cpu data on a different - CPU -* while making global action possible when needed - - by expensive access to all CPUs locks - effectively - resulting in a globally visible critical section. - -Design: -------- - -Basically it is an array of per_cpu spinlocks with the -lg_local_lock/unlock accessing the local CPUs lock object and the -lg_local_lock_cpu/unlock_cpu accessing a remote CPUs lock object -the lg_local_lock has to disable preemption as migration protection so -that the reference to the local CPUs lock does not go out of scope. -Due to the lg_local_lock/unlock only touching cpu-local resources it -is fast. Taking the local lock on a different CPU will be more -expensive but still relatively cheap. - -One can relax the migration constraints by acquiring the current -CPUs lock with lg_local_lock_cpu, remember the cpu, and release that -lock at the end of the critical section even if migrated. This should -give most of the performance benefits without inhibiting migration -though needs careful considerations for nesting of lglocks and -consideration of deadlocks with lg_global_lock. - -The lg_global_lock/unlock locks all underlying spinlocks of all -possible CPUs (including those off-line). The preemption disable/enable -are needed in the non-RT kernels to prevent deadlocks like: - - on cpu 1 - - task A task B - lg_global_lock - got cpu 0 lock - <<<< preempt <<<< - lg_local_lock_cpu for cpu 0 - spin on cpu 0 lock - -On -RT this deadlock scenario is resolved by the arch_spin_locks in the -lglocks being replaced by rt_mutexes which resolve the above deadlock -by boosting the lock-holder. - - -Implementation: ---------------- - -The initial lglock implementation from Nick Piggin used some complex -macros to generate the lglock/brlock in lglock.h - they were later -turned into a set of functions by Andi Kleen [7]. The change to functions -was motivated by the presence of multiple lock users and also by them -being easier to maintain than the generating macros. This change to -functions is also the basis to eliminated the restriction of not -being initializeable in kernel modules (the remaining problem is that -locks are not explicitly initialized - see lockdep-design.txt) - -Declaration and initialization: -------------------------------- - - #include <linux/lglock.h> - - DEFINE_LGLOCK(name) - or: - DEFINE_STATIC_LGLOCK(name); - - lg_lock_init(&name, "lockdep_name_string"); - - on UP this is mapped to DEFINE_SPINLOCK(name) in both cases, note - also that as of 3.18-rc6 all declaration in use are of the _STATIC_ - variant (and it seems that the non-static was never in use). - lg_lock_init is initializing the lockdep map only. - -Usage: ------- - -From the locking semantics it is a spinlock. It could be called a -locality aware spinlock. lg_local_* behaves like a per_cpu -spinlock and lg_global_* like a global spinlock. -No surprises in the API. - - lg_local_lock(*lglock); - access to protected per_cpu object on this CPU - lg_local_unlock(*lglock); - - lg_local_lock_cpu(*lglock, cpu); - access to protected per_cpu object on other CPU cpu - lg_local_unlock_cpu(*lglock, cpu); - - lg_global_lock(*lglock); - access all protected per_cpu objects on all CPUs - lg_global_unlock(*lglock); - - There are no _trylock variants of the lglocks. - -Note that the lg_global_lock/unlock has to iterate over all possible -CPUs rather than the actually present CPUs or a CPU could go off-line -with a held lock [4] and that makes it very expensive. A discussion on -these issues can be found at [5] - -Constraints: ------------- - - * currently the declaration of lglocks in kernel modules is not - possible, though this should be doable with little change. - * lglocks are not recursive. - * suitable for code that can do most operations on the CPU local - data and will very rarely need the global lock - * lg_global_lock/unlock is *very* expensive and does not scale - * on UP systems all lg_* primitives are simply spinlocks - * in PREEMPT_RT the spinlock becomes an rt-mutex and can sleep but - does not change the tasks state while sleeping [6]. - * in PREEMPT_RT the preempt_disable/enable in lg_local_lock/unlock - is downgraded to a migrate_disable/enable, the other - preempt_disable/enable are downgraded to barriers [6]. - The deadlock noted for non-RT above is resolved due to rt_mutexes - boosting the lock-holder in this case which arch_spin_locks do - not do. - -lglocks were designed for very specific problems in the VFS and probably -only are the right answer in these corner cases. Any new user that looks -at lglocks probably wants to look at the seqlock and RCU alternatives as -her first choice. There are also efforts to resolve the RCU issues that -currently prevent using RCU in place of view remaining lglocks. - -Note on brlock history: ------------------------ - -The 'Big Reader' read-write spinlocks were originally introduced by -Ingo Molnar in 2000 (2.4/2.5 kernel series) and removed in 2003. They -later were introduced by the VFS scalability patch set in 2.6 series -again as the "big reader lock" brlock [2] variant of lglock which has -been replaced by seqlock primitives or by RCU based primitives in the -3.13 kernel series as was suggested in [3] in 2003. The brlock was -entirely removed in the 3.13 kernel series. - -Link: 1 http://lkml.org/lkml/2010/8/2/81 -Link: 2 http://lwn.net/Articles/401738/ -Link: 3 http://lkml.org/lkml/2003/3/9/205 -Link: 4 https://lkml.org/lkml/2011/8/24/185 -Link: 5 http://lkml.org/lkml/2011/12/18/189 -Link: 6 https://www.kernel.org/pub/linux/kernel/projects/rt/ - patch series - lglocks-rt.patch.patch -Link: 7 http://lkml.org/lkml/2012/3/5/26
include/linux/lglock.h deleted +0 -76
76 lines not on this page · raw message
kernel/locking/Makefile +0 -1
@@ -15,7 +15,6 @@ obj-$(CONFIG_LOCKDEP) += lockdep_proc.o endif obj-$(CONFIG_SMP) += spinlock.o obj-$(CONFIG_LOCK_SPIN_ON_OWNER) += osq_lock.o -obj-$(CONFIG_SMP) += lglock.o obj-$(CONFIG_PROVE_LOCKING) += spinlock.o obj-$(CONFIG_QUEUED_SPINLOCKS) += qspinlock.o obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
kernel/locking/lglock.c deleted +0 -89
89 lines not on this page · raw message
Quoted 3 lines · Peter Zijlstra
Hi all,
Here are some patches that I've been sitting on for far too long now.
Woohoo, goodbye to bad rubbish.
FWIW, I plugged these into 4.8-rt (motto: if it's gonna go boom anywhere, it'll likely do so in rt), and am beating the living crap out of hotplug in parallel with routine tree merges, builds, serving nfs etc etc, and all seems just peachy. (If anything bad happens, I'll move to a generic tree before reporting 'course)
-Mike