XSA-343 followup patches
v6 cover XSA-343 followup patches
The patches for XSA-343 produced some fallout, especially the event channel locking has shown to be problematic.
Patch 1 is targeting fifo event channels for avoiding any races for the case that the fifo queue has been changed for a specific event channel.
The second patch is modifying the per event channel locking scheme in order to avoid deadlocks and problems due to the event channel lock having been changed to require IRQs off by the XSA-343 patches.
Changes in V6:
- added patch 3 (Jan Beulich)
- switched some more read_trylock() cases to read_lock() (Jan Beulich)
Changes in V5:
- moved evtchn_write_[un]lock() to event_channel.c (Jan Beulich)
- used normal read_lock() in some cases (Jan Beulich)
Changes in V4:
- switched to real rwlock
Changes in V3:
- addressed comments
Juergen Gross (3):
xen/events: access last_priority and last_vcpu_id together xen/evtchn: rework per event channel lock xen/evtchn: revert 52e1fc47abc3a0123
xen/arch/x86/irq.c | 6 +- xen/arch/x86/pv/shim.c | 9 ++- xen/common/event_channel.c | 144 +++++++++++++++++++----------------- xen/common/event_fifo.c | 25 +++++-- xen/include/xen/event.h | 29 ++++++-- xen/include/xen/sched.h | 8 +- xen/include/xsm/xsm.h | 1 - xen/xsm/flask/avc.c | 78 ++----------------- xen/xsm/flask/hooks.c | 10 --- xen/xsm/flask/include/avc.h | 2 - 10 files changed, 139 insertions(+), 173 deletions(-)
Signature · 1 line
2.26.2
PATCH v6 1/3 xen/events: access last_priority and last_vcpu_id together
The queue for a fifo event is depending on the vcpu_id and the priority of the event. When sending an event it might happen the event needs to change queues and the old queue needs to be kept for keeping the links between queue elements intact. For this purpose the event channel contains last_priority and last_vcpu_id values elements for being able to identify the old queue.
In order to avoid races always access last_priority and last_vcpu_id with a single atomic operation avoiding any inconsistencies.
--- xen/common/event_fifo.c | 25 +++++++++++++++++++------ xen/include/xen/sched.h | 3 +-- 2 files changed, 20 insertions(+), 8 deletions(-)
xen/common/event_fifo.c +19 -6
@@ -42,6 +42,14 @@ struct evtchn_fifo_domain {unsigned int num_evtchns; }; +union evtchn_fifo_lastq { +uint32_t raw; +struct { +uint8_t last_priority; +uint16_t last_vcpu_id; + }; +}; +static inline event_word_t *evtchn_fifo_word_from_port (const struct domain *d,unsigned int port) {
@@ -86,16 +94,18 @@ static struct evtchn_fifo_queue *lock_old_queue(const struct domain *d,struct vcpu *v;struct evtchn_fifo_queue *q, *old_q;unsigned int try; +union evtchn_fifo_lastq lastq;for ( try =0 ; try <3 ; try++ ) { - v = d->vcpu[evtchn->last_vcpu_id]; - old_q = &v->evtchn_fifo->queue[evtchn->last_priority]; + lastq.raw =read_atomic (&evtchn->fifo_lastq); + v = d->vcpu[lastq.last_vcpu_id]; + old_q = &v->evtchn_fifo->queue[lastq.last_priority];spin_lock_irqsave (&old_q->lock, *flags); - v = d->vcpu[evtchn->last_vcpu_id]; - q = &v->evtchn_fifo->queue[evtchn->last_priority]; + v = d->vcpu[lastq.last_vcpu_id]; + q = &v->evtchn_fifo->queue[lastq.last_priority];if ( old_q == q )return old_q;
@@ -246,8 +256,11 @@ static void evtchn_fifo_set_pending(struct vcpu *v, struct evtchn *evtchn)/* Moved to a different queue? */ if ( old_q != q ) { - evtchn->last_vcpu_id = v->vcpu_id; - evtchn->last_priority = q->priority; +union evtchn_fifo_lastq lastq = { }; + + lastq.last_vcpu_id = v->vcpu_id; + lastq.last_priority = q->priority; +write_atomic (&evtchn->fifo_lastq, lastq.raw);spin_unlock_irqrestore (&old_q->lock, flags);spin_lock_irqsave (&q->lock, flags);
xen/include/xen/sched.h +1 -2
@@ -114,8 +114,7 @@ struct evtchnu16 virq;/* state == ECS_VIRQ */ } u;u8 priority; -u8 last_priority; -u16 last_vcpu_id; +u32 fifo_lastq;/* Data for fifo events identifying last queue. */ #ifdef CONFIG_XSM union { #ifdef XSM_NEED_GENERIC_EVTCHN_SSID
Signature · 1 line
2.26.2
PATCH v6 2/3 xen/evtchn: rework per event channel lock
In reply to Juergen GrossCurrently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).
- Sending an event needs to use read_trylock() mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).
- Dumping the event channel state for debug purposes is using read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.
- All other cases can use read_lock().
---
V4:
- switch to rwlock
- add ASSERT() to verify correct write_lock() usage
V3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamed evtchn_read_trylock() (Jan Beulich)
- added some comments and an ASSERT() for evtchn_write_lock()
- set EVENT_WRITE_LOCK_INC to INT_MIN
V2:
- added needed barriers
--- xen/arch/x86/irq.c | 6 +- xen/arch/x86/pv/shim.c | 9 +-- xen/common/event_channel.c | 138 +++++++++++++++++++++---------------- xen/include/xen/event.h | 29 ++++++-- xen/include/xen/sched.h | 5 +- 5 files changed, 112 insertions(+), 75 deletions(-)
xen/arch/x86/irq.c +2 -4
@@ -2495,14 +2495,12 @@ static void dump_irqs(unsigned char key) pirq =domain_irq_to_pirq (d, irq); info =pirq_info (d, pirq); evtchn =evtchn_from_port (d, info->evtchn); -local_irq_disable (); -if (spin_trylock (&evtchn->lock) ) +if (evtchn_read_trylock (evtchn) ) { pending =evtchn_is_pending (d, evtchn); masked =evtchn_is_masked (d, evtchn); -spin_unlock (&evtchn->lock); +evtchn_read_unlock (evtchn); } -local_irq_enable (); printk("d%d:%3d(%c%c%c)%c", d->domain_id, pirq, "-P?"[pending], "-M?"[masked], info->masked ? 'M' : '-',
xen/arch/x86/pv/shim.c +5 -4
@@ -660,11 +660,12 @@ void pv_shim_inject_evtchn(unsigned int port)if (port_is_valid (guest, port) ) {struct evtchn *chn =evtchn_from_port (guest, port); -unsigned long flags; -spin_lock_irqsave (&chn->lock, flags); -evtchn_port_set_pending (guest, chn->notify_vcpu_id, chn); -spin_unlock_irqrestore (&chn->lock, flags); +if (evtchn_read_trylock (chn) ) + { +evtchn_port_set_pending (guest, chn->notify_vcpu_id, chn); +evtchn_read_unlock (chn); + } } }
xen/common/event_channel.c +78 -60
384 lines not on this page · raw message
xen/include/xen/event.h +23 -6
@@ -105,6 +105,21 @@ void notify_via_xen_event_channel(struct domain *ld, int lport);#define bucket_from_port (d, p) \ ((group_from_port(d, p))[((p) % EVTCHNS_PER_GROUP) / EVTCHNS_PER_BUCKET]) +static inline void evtchn_read_lock (struct evtchn *evtchn) +{ +read_lock (&evtchn->lock); +} + +static inline bool evtchn_read_trylock (struct evtchn *evtchn) +{ +return read_trylock (&evtchn->lock); +} + +static inline void evtchn_read_unlock (struct evtchn *evtchn) +{ +read_unlock (&evtchn->lock); +} +static inline bool_t port_is_valid (struct domain *d,unsigned int p) {if ( p >=read_atomic (&d->valid_evtchns) )
@@ -235,11 +250,12 @@ static inline bool evtchn_port_is_masked(struct domain *d, evtchn_port_t port) {struct evtchn *evtchn =evtchn_from_port (d, port);bool rc; -unsigned long flags; -spin_lock_irqsave (&evtchn->lock, flags); +evtchn_read_lock (evtchn); + rc =evtchn_is_masked (d, evtchn); -spin_unlock_irqrestore (&evtchn->lock, flags); + +evtchn_read_unlock (evtchn);return rc; }
@@ -252,12 +268,13 @@ static inline int evtchn_port_poll(struct domain *d, evtchn_port_t port)if (port_is_valid (d, port) ) {struct evtchn *evtchn =evtchn_from_port (d, port); -unsigned long flags; -spin_lock_irqsave (&evtchn->lock, flags); +evtchn_read_lock (evtchn); +if (evtchn_usable (evtchn) ) rc =evtchn_is_pending (d, evtchn); -spin_unlock_irqrestore (&evtchn->lock, flags); + +evtchn_read_unlock (evtchn); }return rc;
xen/include/xen/sched.h +4 -1
@@ -85,7 +85,7 @@ extern domid_t hardware_domid;struct evtchn { -spinlock_t lock; +rwlock_t lock;#define ECS_FREE 0/* Channel is available for use. */ #define ECS_RESERVED 1/* Channel is reserved. */ #define ECS_UNBOUND 2/* Channel is waiting to bind to a remote domain. */
@@ -114,6 +114,9 @@ struct evtchnu16 virq;/* state == ECS_VIRQ */ } u;u8 priority; +#ifndef NDEBUG +u8 old_state;/* State when taking lock in write mode. */ +#endif u32 fifo_lastq;/* Data for fifo events identifying last queue. */ #ifdef CONFIG_XSM union {
Signature · 1 line
2.26.2
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Quoted 43 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MIN
Quoted 4 lines
V2:
- added needed barriersSigned-off-by Juergen Gross <[email protected]>
I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
I also think this will want backporting beyond just the fully maintained branches.
Jan
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Hi,
Quoted 47 lines · Jan Beulich
Quoted 46 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MINV2:
- added needed barriers
Quoted 6 lines
Quoted 1 line
Signed-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
IIRC, Citrix originally reported the issues. I would like to give them an opportunity to test the patches and confirm this effectively fixed there issues.
@Roger, @Andrew, could you give a try to confirm this unblock the vm event issue?
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Quoted 54 lines · Julien Grall
Hi,
Quoted 51 lines · Jan Beulich
Quoted 43 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MINQuoted 4 lines
V2:
- added needed barriersSigned-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>
Quoted 7 lines
Quoted 2 lines
I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
IIRC, Citrix originally reported the issues. I would like to give them an opportunity to test the patches and confirm this effectively fixed there issues.
@Roger, @Andrew, could you give a try to confirm this unblock the vm event issue?
It should be noted that this series ought to fix current unstable failures of XSM tests, as those are triggering the advanced lock checks of rwlocks due to the per-event channel lock disabling interrupts.
Juergen
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
In reply to Julien GrallQuoted 52 lines · Julien Grall
Hi,
Quoted 49 lines · Jan Beulich
Quoted 47 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MINV2:
- added needed barriersSigned-off-by Juergen Gross <[email protected]>
Quoted 8 lines
Quoted 4 lines
Reviewed-by Jan Beulich <[email protected]>I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
IIRC, Citrix originally reported the issues. I would like to give them an opportunity to test the patches and confirm this effectively fixed there issues.
I would consider waiting longer, but I'd like to get staging unblocked. Just like with 52e1fc47abc3a0123 ("evtchn/Flask: pre-allocate node on send path") we can always decide to revert / fix up afterwards. The patch here surely is an improvement, even if it was to turn out it doesn't fix all issues yes. I'd appreciate if you would confirm you don't object to the patch going in - I'll wait a few more hours, perhaps until around noon.
Jan
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Hi,
Quoted 55 lines · Jan Beulich
Quoted 54 lines · Julien Grall
Hi,
Quoted 51 lines · Jan Beulich
Quoted 43 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MINQuoted 4 lines
V2:
- added needed barriersSigned-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>
Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
IIRC, Citrix originally reported the issues. I would like to give them an opportunity to test the patches and confirm this effectively fixed there issues.
I would consider waiting longer, but I'd like to get staging unblocked.
So the plan is to have the patches sitting in staging for a few days and then backport?
Quoted 6 lines
Just like with
52e1fc47abc3a0123("evtchn/Flask: pre-allocate node on send path") we can always decide to revert / fix up afterwards. The patch here surely is an improvement, even if it was to turn out it doesn't fix all issues yes. I'd appreciate if you would confirm you don't object to the patch going in - I'll wait a few more hours, perhaps until around noon.
I would suggest to wait until noon and if you don't get any answer, then merge it.
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Quoted 61 lines · Julien Grall
Hi,
Quoted 58 lines · Jan Beulich
Quoted 57 lines · Julien Grall
Hi,
Quoted 53 lines · Jan Beulich
Quoted 43 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>---
V4:
- switch to rwlock
- addASSERT()to verify correctwrite_lock()usageV3:
- corrected a copy-and-paste error (Jan Beulich)
- corrected unlocking in two cases (Jan Beulich)
- renamedevtchn_read_trylock()(Jan Beulich)
- added some comments and anASSERT()forevtchn_write_lock()
- setEVENT_WRITE_LOCK_INCtoINT_MINQuoted 4 lines
V2:
- added needed barriersSigned-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>I'll give it overnight for others to possibly comment, but I'd like to get this in tomorrow if at all possible.
Quoted 8 lines
Quoted 5 lines
Quoted 3 lines
IIRC, Citrix originally reported the issues. I would like to give them an opportunity to test the patches and confirm this effectively fixed there issues.
I would consider waiting longer, but I'd like to get staging unblocked.
So the plan is to have the patches sitting in staging for a few days and then backport?
Right, the usual thing - wait at least until a push has happened. Unless we learn of problems with the change, I definitely want to have this in for 4.14.1.
Quoted 8 lines
Quoted 6 lines
Just like with
52e1fc47abc3a0123("evtchn/Flask: pre-allocate node on send path") we can always decide to revert / fix up afterwards. The patch here surely is an improvement, even if it was to turn out it doesn't fix all issues yes. I'd appreciate if you would confirm you don't object to the patch going in - I'll wait a few more hours, perhaps until around noon.I would suggest to wait until noon and if you don't get any answer, then merge it.
Okay.
Jan
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
In reply to Juergen GrossHi Juergen,
Quoted 23 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).
Quoted 8 lines
- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().Fixes e045199c7c9c54 ("evtchn: address races with evtchn_reset()")Signed-off-by Juergen Gross <[email protected]>
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
In reply to Juergen GrossQuoted 23 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).
Quoted 5 lines
- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().
One of the implications is that racing invocations of ->set_pending() are now possible for the same port. Beyond what I said in reply to 0/3 already, I'm afraid there are (latent) issues:
1) The update of ->pending (or basically any bitfield in struct evtchn, or yet more generically any field getting updated in a read- modify-write fashion) is no longer generally safe in any of the hooks called with just a read lock held. ->pending itself is not an issue now merely because it shares storage only with xen_consumer, which won't get updated once a port was bound.
2) Of two racing sends, one may now complete without the port actually having got fully recorded as linked in the FIFO code. This is because the party losing the race of setting EVTCHN_FIFO_LINKED will return early, without regard to whether the winner has made enough progress. (Of course this is possible only with an intermediate queue change, as only then the lock would become available to the second of the senders early enough.)
I've gone through other functions called from this path and didn't find any further race potential there, but I'm not entirely certain I didn't miss anything.
Jan
Re: [PATCH v6 2/3] xen/evtchn: rework per event channel lock
Quoted 34 lines · Jan Beulich
Quoted 23 lines · Juergen Gross
Currently the lock for a single event channel needs to be taken with interrupts off, which causes deadlocks in some cases.
Rework the per event channel lock to be non-blocking for the case of sending an event and removing the need for disabling interrupts for taking the lock.
The lock is needed for avoiding races between event channel state changes (creation, closing, binding) against normal operations (set pending, [un]masking, priority changes).
Use a rwlock, but with some restrictions:
- Changing the state of an event channel (creation, closing, binding) needs to use
write_lock(), with ASSERT()ing that the lock is taken as writer only when the state of the event channel is either before or after the locked region appropriate (either free or unbound).- Sending an event needs to use
read_trylock()mostly, in case of not obtaining the lock the operation is omitted. This is needed as sending an event can happen with interrupts off (at least in some cases).Quoted 5 lines
- Dumping the event channel state for debug purposes is using
read_trylock(), too, in order to avoid blocking in case the lock is taken as writer for a long time.- All other cases can use
read_lock().One of the implications is that racing invocations of ->set_pending() are now possible for the same port. Beyond what I said in reply to 0/3 already, I'm afraid there are (latent) issues:
Quoted 6 lines
1) The update of ->pending (or basically any bitfield in struct evtchn, or yet more generically any field getting updated in a read- modify-write fashion) is no longer generally safe in any of the hooks called with just a read lock held. ->pending itself is not an issue now merely because it shares storage only with
xen_consumer, which won't get updated once a port was bound.
This is fragile.
We should put the pending indicator into a dedicated byte.
Quoted 7 lines
2) Of two racing sends, one may now complete without the port actually having got fully recorded as linked in the FIFO code. This is because the party losing the race of setting
EVTCHN_FIFO_LINKEDwill return early, without regard to whether the winner has made enough progress. (Of course this is possible only with an intermediate queue change, as only then the lock would become available to the second of the senders early enough.)
No, I don't think this is limited to a queue change. If a caller of evtchn_fifo_set_pending() is being interrupted after setting EVTCHN_FIFO_PENDING, and then a second caller can make it to setting EVTCHN_FIFO_LINKED, the first caller won't even try to take the queue lock, resulting in evtchn_check_pollers() being called before the event might have been put properly into the queue.
I'd suggest to extend the fifo queue lock region in order to mitigate this problem.
Quoted 4 lines
I've gone through other functions called from this path and didn't find any further race potential there, but I'm not entirely certain I didn't miss anything.
I can prepare a patch if you agree my ideas.
Juergen
PATCH v6 3/3 xen/evtchn: revert 52e1fc47abc3a0123
In reply to Juergen GrossWith the event channel lock no longer disabling interrupts commit 52e1fc47abc3a0123 ("evtchn/Flask: pre-allocate node on send path") can be reverted again.
--- xen/common/event_channel.c | 6 --- xen/include/xsm/xsm.h | 1 - xen/xsm/flask/avc.c | 78 ++++--------------------------------- xen/xsm/flask/hooks.c | 10 ----- xen/xsm/flask/include/avc.h | 2 - 5 files changed, 7 insertions(+), 90 deletions(-)
xen/common/event_channel.c +0 -6
@@ -740,12 +740,6 @@ int evtchn_send(struct domain *ld, unsigned int lport)if ( !port_is_valid (ld, lport) )return -EINVAL ; -/* -* As the call further down needs to avoid allocations (due to running -* with IRQs off), give XSM a chance to pre-allocate if needed. -*/ -xsm_evtchn_send (XSM_HOOK , ld,NULL ); - lchn =evtchn_from_port (ld, lport);evtchn_read_lock (lchn);
xen/include/xsm/xsm.h +0 -1
@@ -59,7 +59,6 @@ struct xsm_operations {int (*evtchn_interdomain) (struct domain *d1,struct evtchn *chn1,struct domain *d2,struct evtchn *chn2);void (*evtchn_close_post) (struct evtchn *chn); -/* Note: Next hook may be called with 'chn' set to NULL. See call site. */ int (*evtchn_send) (struct domain *d,struct evtchn *chn);int (*evtchn_status) (struct domain *d,struct evtchn *chn);int (*evtchn_reset) (struct domain *d1,struct domain *d2);
xen/xsm/flask/avc.c +7 -71
95 lines not on this page · raw message
xen/xsm/flask/hooks.c +0 -10
@@ -281,16 +281,6 @@ static int flask_evtchn_send(struct domain *d, struct evtchn *chn) {int rc; -/* -* When called with non-NULL chn, memory allocation may not be permitted. -* Allow AVC to preallocate nodes as necessary upon early notification. -*/ -if ( !chn ) - { -avc_prealloc (); -return 0 ; - } -switch ( chn->state ) {case ECS_INTERDOMAIN :
xen/xsm/flask/include/avc.h +0 -2
@@ -91,8 +91,6 @@ int avc_has_perm_noaudit(u32 ssid, u32 tsid, u16 tclass, u32 requested,int avc_has_perm (u32 ssid,u32 tsid,u16 tclass,u32 requested,struct avc_audit_data *auditdata); -void avc_prealloc (void ); -/* Exported to selinuxfs */ struct xen_flask_hash_stats ;int avc_get_hash_stats (struct xen_flask_hash_stats *arg);
Signature · 1 line
2.26.2
Re: [PATCH v6 3/3] xen/evtchn: revert 52e1fc47abc3a0123
Quoted 5 lines · Juergen Gross
With the event channel lock no longer disabling interrupts commit
52e1fc47abc3a0123("evtchn/Flask: pre-allocate node on send path") can be reverted again.Signed-off-by Juergen Gross <[email protected]>
Hi,
Quoted 21 lines · Juergen Gross
The patches for XSA-343 produced some fallout, especially the event channel locking has shown to be problematic.
Patch 1 is targeting fifo event channels for avoiding any races for the case that the fifo queue has been changed for a specific event channel.
The second patch is modifying the per event channel locking scheme in order to avoid deadlocks and problems due to the event channel lock having been changed to require IRQs off by the XSA-343 patches.
Changes in V6:
- added patch 3 (Jan Beulich)
- switched some moreread_trylock()cases toread_lock()(Jan Beulich)Changes in V5:
- moved evtchn_write_[un]lock() toevent_channel.c(Jan Beulich)
- used normalread_lock()in some cases (Jan Beulich)Changes in V4:
- switched to real rwlock
Quoted 7 lines
Changes in V3:
- addressed commentsJuergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123
While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Cheers,
Signature · 1 line
Julien Grall
Quoted 10 lines · Julien Grall
Quoted 4 lines · Juergen Gross
Juergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
Quoted 6 lines
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case. Furthermore I clearly view this as not a backporting candidate, while the other two are (as I did previously indicate). Hence the latter two patches wanted re-basing ahead of the first one anyway, to ease the backports.
While I will accept there are different views possible here, I also don't think sending mail in such a case is a good use of resources. The information what was or was not committed is readily available. Personally I view such mails as at least very close to spam.
Irrespective of the above I'm sorry for any inconvenience caused.
Jan
Quoted 18 lines · Jan Beulich
Quoted 10 lines · Julien Grall
Quoted 4 lines · Juergen Gross
Juergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
Quoted 6 lines
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Quoted 7 lines
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case. Furthermore I clearly view this as not a backporting candidate, while the other two are (as I did previously indicate). Hence the latter two patches wanted re-basing ahead of the first one anyway, to ease the backports.
Consider an NMI during evtchn_fifo_set_pending() between updating last_vcpu_id and last_priority, while on another cpu a concurrent evtchn_fifo_set_pending() is being called. On that other cpu lock_old_queue() might return a wrong queue as it will read only the new last_vcpu_id, but not the new last_priority value.
Juergen
Quoted 27 lines · Jürgen Groß
Quoted 18 lines · Jan Beulich
Quoted 10 lines · Julien Grall
Quoted 4 lines · Juergen Gross
Juergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
Quoted 6 lines
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Quoted 7 lines
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case. Furthermore I clearly view this as not a backporting candidate, while the other two are (as I did previously indicate). Hence the latter two patches wanted re-basing ahead of the first one anyway, to ease the backports.
Quoted 5 lines
Consider an NMI during
evtchn_fifo_set_pending()between updatinglast_vcpu_idandlast_priority, while on another cpu a concurrentevtchn_fifo_set_pending()is being called. On that other cpulock_old_queue()might return a wrong queue as it will read only the newlast_vcpu_id, but not the newlast_priorityvalue.
Which has become possible only as of patch 2 of this series, i.e. this one really was a prereq without its description making this clear. Now that it'll go in on top of the other two, there's no strict need to change the description anymore, though. But I take from this that I should also queue it up for backporting then.
Jan
Hi Jan,
Quoted 15 lines · Jan Beulich
Quoted 14 lines · Julien Grall
Quoted 4 lines · Juergen Gross
Juergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Quoted 7 lines
Quoted 2 lines
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case.
I was under the impression that the committer job is mostly mechanical (i.e. collecting tags and applying patches). There are no rules in MAINTAINERS that mention committers can decide what gets committed as long as maintainers approved it and there are no strong objections.
Quoted 4 lines
Furthermore I clearly view
this as not a backporting candidate, while the other two are (as I did previously indicate). Hence the latter two patches wanted re-basing ahead of the first one anyway, to ease the backports.
I understand the backport concern. However, if there were clash, then it means you had to resolve them on commit to staging. Surely, they were quite minimal otherwise you would have sent an e-mail on xen-devel, right?
Quoted 3 lines
While I will accept there are different views possible here, I also
don't think sending mail in such a case is a good use of resources.
The information what was or was not committed is readily available. > Personally I view such mails as at least very close to spam.
This is a matter of perspective. It helps to confirm with the contributor that it was fine to merge only part of the series (multiple pair of eyes is always better than one...) or mentioning any clash/reworked.
It also makes easier for reviewers to figure out what was committed as it can be difficult to know if a patch was merged because commit title can be altered (even simply dropping the prefix "xen/" can take a coule of more minutes to pinpoint commit).
Therefore, I think there is a value for such e-mail to be sent out. It will likely improve coordination among the member of the community.
I would be happy to consider different approach if it fullfills that goal.
Cheers,
Signature · 1 line
Julien Grall
Julien Grall writes ("Re: [PATCH v6 0/3] XSA-343 followup patches"):
Quoted 10 lines · Jan Beulich
Quoted 4 lines
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case.
I was under the impression that the committer job is mostly mechanical (i.e. collecting tags and applying patches). There are no rules in
MAINTAINERSthat mention committers can decide what gets committed as long as maintainers approved it and there are no strong objections.
I think in practice committers need to exercise quite a bit of judgement. I often find myself deciding on what seem to be edge cases of the rules. I also sometimes, with something which has the formally needed acks, but which seems like it might be controversial or awkward, decide to just make an extra double-check. I sometimes even commit something when maybe the formal rules wouldn't permit it, when I'm confident that the relevant maintainer(s) etc. wouldn't object - an example being when something is badly broken and this is allegedly the fix.
However, I don't agree that a committer should omit committing something which is acked, and is part of a series which they are committing, simply because they don't see the need for the patch.
If a committer who is also a maintainer has a firm objection, they should state that objection as a formal NAK. If a formal NAK is not warranted, a committer should not engage in passive obstruction.
Also, a committer should not "silently" commit only part of a series.
In summary, committing something is not a declaration by the committer that they approve of the patch on a technical level.
It is a declaration that (in the committer's view) the patch is properly acked/approved, and that therefore according to our shared understanding of the community's processes, it ought to go in.
That might even occur if the committer has an outstanding technical objection. I have certainly committed things that I didn't really like very much, on the grounds that they had enough acks and that I didn't feel I wanted to give it a formal NAK.
If it would help a committer feel more comfortable to be explicit about this, there are a number of approaches available: the committer could commit the patch but also reply to it on-list restating their objection but saying that they are committing it despite the objection, because of others' acks.
If it is felt desirable to record this information in the repository, one could write something like
(which I think is not the same as Nacked-by) or even add a note in the commit message like
[ I am committing this, even though I don't think it is
necessary, because it has the requisite acks. I do not think it warrants a nack. -iwj ]
Quoted 4 lines
This is a matter of perspective. It helps to confirm with the contributor that it was fine to merge only part of the series (multiple pair of eyes is always better than one...) or mentioning any clash/reworked.
I think it is especially important to send an email about things being committed when what has happened might be surprising. For example, if only part of a series is committed.
Thanks,
Ian.
Quoted 59 lines
-----Original Message-----
From: Xen-devel <[email protected]> On Behalf Of Julien Grall
Sent: 18 November 2020 14:18
To: Jan Beulich <[email protected]>
Cc: Andrew Cooper <[email protected]>; George Dunlap <[email protected]>; Ian Jackson <[email protected]>; Stefano Stabellini <[email protected]>; Wei Liu <[email protected]>; Roger Pau Monné <[email protected]>; Daniel De Graaf <[email protected]>; [email protected]; xen- [email protected]; Juergen Gross <[email protected]>
Subject: Re: [PATCH v6 0/3] XSA-343 followup patchesHi Jan,
Quoted 15 lines · Jan Beulich
Quoted 14 lines · Julien Grall
Quoted 4 lines · Juergen Gross
Juergen Gross (3):
xen/events: accesslast_priorityandlast_vcpu_idtogether xen/evtchn: rework per event channel lock xen/evtchn: revert52e1fc47abc3a0123While looking at the list of commits, I noticed that the first patch hasn't been committed. They were all acked/reviewed, so I am a bit puzzled why this was omitted...
I have nearly missed as I was expecting the 3 patches to be committed together. May I suggest that in the future we reply to the cover letter and mention which patches are (or not) committed?
Quoted 7 lines
Quoted 2 lines
Regarding patch #1, I will commit it tomorrow unless there are strong objections against.
Without a clear outline of what would break with the present logic, I had previously indicated I'm not convinced of the change. This isn't a strong objection, no, but I still wouldn't want to see my name associated with it in such a case.
I was under the impression that the committer job is mostly mechanical (i.e. collecting tags and applying patches). There are no rules in
MAINTAINERSthat mention committers can decide what gets committed as long as maintainers approved it and there are no strong objections.Quoted 4 lines
Furthermore I clearly view
this as not a backporting candidate, while the other two are (as I did previously indicate). Hence the latter two patches wanted re-basing ahead of the first one anyway, to ease the backports.I understand the backport concern. However, if there were clash, then it means you had to resolve them on commit to staging. Surely, they were quite minimal otherwise you would have sent an e-mail on xen-devel, right?
Quoted 3 lines
While I will accept there are different views possible here, I also
don't think sending mail in such a case is a good use of resources.
The information what was or was not committed is readily available. > Personally I view such mailsas at least very close to spam.
This is a matter of perspective. It helps to confirm with the contributor that it was fine to merge only part of the series (multiple pair of eyes is always better than one...) or mentioning any clash/reworked.
Quoted 7 lines
It also makes easier for reviewers to figure out what was committed as it can be difficult to know if a patch was merged because commit title can be altered (even simply dropping the prefix "xen/" can take a coule of more minutes to pinpoint commit).
Therefore, I think there is a value for such e-mail to be sent out. It will likely improve coordination among the member of the community.
+1
Knowing that part of a long series has already been committed would be useful. When I do the usual pull/rebase dance prior to re-submitting I have, more than once, been surprised by rebase failures because some of the patches had been committed but were modified in doing do. It's not a massive problem but an email would have at least made me aware I needed to be a bit more careful.
Paul
Quoted 7 lines
I would be happy to consider different approach if it fullfills that goal.
Cheers,
--
Julien Grall