mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Paolo Bonzini](/assets/img/avatar_default.png)
Linu Cherian reported a WARN in cleanup_srcu_struct() when shutting down a guest running iperf on a VFIO assigned device. This happens because irqfd_wakeup() calls srcu_read_lock(&kvm->irq_srcu) in interrupt context, while a worker thread does the same inside kvm_set_irq(). If the interrupt happens while the worker thread is executing __srcu_read_lock(), updates to the Classic SRCU ->lock_count[] field or the Tree SRCU ->srcu_lock_count[] field can be lost. The docs say you are not supposed to call srcu_read_lock() and srcu_read_unlock() from irq context, but KVM interrupt injection happens from (host) interrupt context and it would be nice if SRCU supported the use case. KVM is using SRCU here not really for the "sleepable" part, but rather due to its IPI-free fast detection of grace periods. It is therefore not desirable to switch back to RCU, which would effectively revert commit719d93cd5f
("kvm/irqchip: Speed up KVM_SET_GSI_ROUTING", 2014-01-16). However, the docs are overly conservative. You can have an SRCU instance only has users in irq context, and you can mix process and irq context as long as process context users disable interrupts. In addition, __srcu_read_unlock() actually uses this_cpu_dec() on both Tree SRCU and Classic SRCU. For those two implementations, only srcu_read_lock() is unsafe. When Classic SRCU's __srcu_read_unlock() was changed to use this_cpu_dec(), in commit5a41344a3d
("srcu: Simplify __srcu_read_unlock() via this_cpu_dec()", 2012-11-29), __srcu_read_lock() did two increments. Therefore it kept __this_cpu_inc(), with preempt_disable/enable in the caller. Tree SRCU however only does one increment, so on most architectures it is more efficient for __srcu_read_lock() to use this_cpu_inc(), and any performance differences appear to be down in the noise. Unlike Classic and Tree SRCU, Tiny SRCU does increments and decrements on a single variable. Therefore, as Peter Zijlstra pointed out, Tiny SRCU's implementation already supports mixed-context use of srcu_read_lock() and srcu_read_unlock(), at least as long as uses of srcu_read_lock() and srcu_read_unlock() in each handler are nested and paired properly. In other words, it is still illegal to (say) invoke srcu_read_lock() in an interrupt handler and to invoke the matching srcu_read_unlock() in a softirq handler. Therefore, the only change required for Tiny SRCU is to its comments. Fixes:719d93cd5f
("kvm/irqchip: Speed up KVM_SET_GSI_ROUTING") Reported-by: Linu Cherian <linuc.decode@gmail.com> Suggested-by: Linu Cherian <linuc.decode@gmail.com> Cc: kvm@vger.kernel.org Signed-off-by: Paolo Bonzini <pbonzini@redhat.com> Cc: Linus Torvalds <torvalds@linux-foundation.org> Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com> Tested-by: Paolo Bonzini <pbonzini@redhat.com>
217 lines
6.5 KiB
C
217 lines
6.5 KiB
C
/*
|
|
* Sleepable Read-Copy Update mechanism for mutual exclusion,
|
|
* tiny version for non-preemptible single-CPU use.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you can access it online at
|
|
* http://www.gnu.org/licenses/gpl-2.0.html.
|
|
*
|
|
* Copyright (C) IBM Corporation, 2017
|
|
*
|
|
* Author: Paul McKenney <paulmck@us.ibm.com>
|
|
*/
|
|
|
|
#include <linux/export.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/preempt.h>
|
|
#include <linux/rcupdate_wait.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/srcu.h>
|
|
|
|
#include <linux/rcu_node_tree.h>
|
|
#include "rcu_segcblist.h"
|
|
#include "rcu.h"
|
|
|
|
static int init_srcu_struct_fields(struct srcu_struct *sp)
|
|
{
|
|
sp->srcu_lock_nesting[0] = 0;
|
|
sp->srcu_lock_nesting[1] = 0;
|
|
init_swait_queue_head(&sp->srcu_wq);
|
|
sp->srcu_gp_seq = 0;
|
|
rcu_segcblist_init(&sp->srcu_cblist);
|
|
sp->srcu_gp_running = false;
|
|
sp->srcu_gp_waiting = false;
|
|
sp->srcu_idx = 0;
|
|
INIT_WORK(&sp->srcu_work, srcu_drive_gp);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_DEBUG_LOCK_ALLOC
|
|
|
|
int __init_srcu_struct(struct srcu_struct *sp, const char *name,
|
|
struct lock_class_key *key)
|
|
{
|
|
/* Don't re-initialize a lock while it is held. */
|
|
debug_check_no_locks_freed((void *)sp, sizeof(*sp));
|
|
lockdep_init_map(&sp->dep_map, name, key, 0);
|
|
return init_srcu_struct_fields(sp);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__init_srcu_struct);
|
|
|
|
#else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
/*
|
|
* init_srcu_struct - initialize a sleep-RCU structure
|
|
* @sp: structure to initialize.
|
|
*
|
|
* Must invoke this on a given srcu_struct before passing that srcu_struct
|
|
* to any other function. Each srcu_struct represents a separate domain
|
|
* of SRCU protection.
|
|
*/
|
|
int init_srcu_struct(struct srcu_struct *sp)
|
|
{
|
|
return init_srcu_struct_fields(sp);
|
|
}
|
|
EXPORT_SYMBOL_GPL(init_srcu_struct);
|
|
|
|
#endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
|
|
|
|
/*
|
|
* cleanup_srcu_struct - deconstruct a sleep-RCU structure
|
|
* @sp: structure to clean up.
|
|
*
|
|
* Must invoke this after you are finished using a given srcu_struct that
|
|
* was initialized via init_srcu_struct(), else you leak memory.
|
|
*/
|
|
void cleanup_srcu_struct(struct srcu_struct *sp)
|
|
{
|
|
WARN_ON(sp->srcu_lock_nesting[0] || sp->srcu_lock_nesting[1]);
|
|
flush_work(&sp->srcu_work);
|
|
WARN_ON(rcu_seq_state(sp->srcu_gp_seq));
|
|
WARN_ON(sp->srcu_gp_running);
|
|
WARN_ON(sp->srcu_gp_waiting);
|
|
WARN_ON(!rcu_segcblist_empty(&sp->srcu_cblist));
|
|
}
|
|
EXPORT_SYMBOL_GPL(cleanup_srcu_struct);
|
|
|
|
/*
|
|
* Counts the new reader in the appropriate per-CPU element of the
|
|
* srcu_struct. Can be invoked from irq/bh handlers, but the matching
|
|
* __srcu_read_unlock() must be in the same handler instance. Returns an
|
|
* index that must be passed to the matching srcu_read_unlock().
|
|
*/
|
|
int __srcu_read_lock(struct srcu_struct *sp)
|
|
{
|
|
int idx;
|
|
|
|
idx = READ_ONCE(sp->srcu_idx);
|
|
WRITE_ONCE(sp->srcu_lock_nesting[idx], sp->srcu_lock_nesting[idx] + 1);
|
|
return idx;
|
|
}
|
|
EXPORT_SYMBOL_GPL(__srcu_read_lock);
|
|
|
|
/*
|
|
* Removes the count for the old reader from the appropriate element of
|
|
* the srcu_struct.
|
|
*/
|
|
void __srcu_read_unlock(struct srcu_struct *sp, int idx)
|
|
{
|
|
int newval = sp->srcu_lock_nesting[idx] - 1;
|
|
|
|
WRITE_ONCE(sp->srcu_lock_nesting[idx], newval);
|
|
if (!newval && READ_ONCE(sp->srcu_gp_waiting))
|
|
swake_up(&sp->srcu_wq);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__srcu_read_unlock);
|
|
|
|
/*
|
|
* Workqueue handler to drive one grace period and invoke any callbacks
|
|
* that become ready as a result. Single-CPU and !PREEMPT operation
|
|
* means that we get away with murder on synchronization. ;-)
|
|
*/
|
|
void srcu_drive_gp(struct work_struct *wp)
|
|
{
|
|
int idx;
|
|
struct rcu_cblist ready_cbs;
|
|
struct srcu_struct *sp;
|
|
struct rcu_head *rhp;
|
|
|
|
sp = container_of(wp, struct srcu_struct, srcu_work);
|
|
if (sp->srcu_gp_running || rcu_segcblist_empty(&sp->srcu_cblist))
|
|
return; /* Already running or nothing to do. */
|
|
|
|
/* Tag recently arrived callbacks and wait for readers. */
|
|
WRITE_ONCE(sp->srcu_gp_running, true);
|
|
rcu_segcblist_accelerate(&sp->srcu_cblist,
|
|
rcu_seq_snap(&sp->srcu_gp_seq));
|
|
rcu_seq_start(&sp->srcu_gp_seq);
|
|
idx = sp->srcu_idx;
|
|
WRITE_ONCE(sp->srcu_idx, !sp->srcu_idx);
|
|
WRITE_ONCE(sp->srcu_gp_waiting, true); /* srcu_read_unlock() wakes! */
|
|
swait_event(sp->srcu_wq, !READ_ONCE(sp->srcu_lock_nesting[idx]));
|
|
WRITE_ONCE(sp->srcu_gp_waiting, false); /* srcu_read_unlock() cheap. */
|
|
rcu_seq_end(&sp->srcu_gp_seq);
|
|
|
|
/* Update callback list based on GP, and invoke ready callbacks. */
|
|
rcu_segcblist_advance(&sp->srcu_cblist,
|
|
rcu_seq_current(&sp->srcu_gp_seq));
|
|
if (rcu_segcblist_ready_cbs(&sp->srcu_cblist)) {
|
|
rcu_cblist_init(&ready_cbs);
|
|
local_irq_disable();
|
|
rcu_segcblist_extract_done_cbs(&sp->srcu_cblist, &ready_cbs);
|
|
local_irq_enable();
|
|
rhp = rcu_cblist_dequeue(&ready_cbs);
|
|
for (; rhp != NULL; rhp = rcu_cblist_dequeue(&ready_cbs)) {
|
|
local_bh_disable();
|
|
rhp->func(rhp);
|
|
local_bh_enable();
|
|
}
|
|
local_irq_disable();
|
|
rcu_segcblist_insert_count(&sp->srcu_cblist, &ready_cbs);
|
|
local_irq_enable();
|
|
}
|
|
WRITE_ONCE(sp->srcu_gp_running, false);
|
|
|
|
/*
|
|
* If more callbacks, reschedule ourselves. This can race with
|
|
* a call_srcu() at interrupt level, but the ->srcu_gp_running
|
|
* checks will straighten that out.
|
|
*/
|
|
if (!rcu_segcblist_empty(&sp->srcu_cblist))
|
|
schedule_work(&sp->srcu_work);
|
|
}
|
|
EXPORT_SYMBOL_GPL(srcu_drive_gp);
|
|
|
|
/*
|
|
* Enqueue an SRCU callback on the specified srcu_struct structure,
|
|
* initiating grace-period processing if it is not already running.
|
|
*/
|
|
void call_srcu(struct srcu_struct *sp, struct rcu_head *head,
|
|
rcu_callback_t func)
|
|
{
|
|
unsigned long flags;
|
|
|
|
head->func = func;
|
|
local_irq_save(flags);
|
|
rcu_segcblist_enqueue(&sp->srcu_cblist, head, false);
|
|
local_irq_restore(flags);
|
|
if (!READ_ONCE(sp->srcu_gp_running))
|
|
schedule_work(&sp->srcu_work);
|
|
}
|
|
EXPORT_SYMBOL_GPL(call_srcu);
|
|
|
|
/*
|
|
* synchronize_srcu - wait for prior SRCU read-side critical-section completion
|
|
*/
|
|
void synchronize_srcu(struct srcu_struct *sp)
|
|
{
|
|
struct rcu_synchronize rs;
|
|
|
|
init_rcu_head_on_stack(&rs.head);
|
|
init_completion(&rs.completion);
|
|
call_srcu(sp, &rs.head, wakeme_after_rcu);
|
|
wait_for_completion(&rs.completion);
|
|
destroy_rcu_head_on_stack(&rs.head);
|
|
}
|
|
EXPORT_SYMBOL_GPL(synchronize_srcu);
|