vfio/pds: Fixes for locking bugs
Subsystems (4)
Brett Creeley
maintainerv4 cover vfio/pds: Fixes for locking bugs
This series contains fixes for locking bugs in the recently introduced pds-vfio-pci driver. There was an initial bug reported by Dan Carpenter at:
https://lore.kernel.org/kvm/[email protected]/
However, more locking bugs were found when looking into the previously mentioned issue. So, all fixes are included in this series.
v4:
- Drop patch 1/3 since it added a spinlock_init that was later replaced by a mutex_init anyway
v3:
https://lore.kernel.org/kvm/[email protected]/
- Change reset lock from spinlock to mutex
v2:
https://lore.kernel.org/kvm/[email protected]/
- Trim the OOPs in the patch commit messages
- Rework patch 3/3 to only unlock the spinlock once
- Destroy the state_mutex in the driver specific vfio_device_ops.release callback
v1:
https://lore.kernel.org/kvm/[email protected]/
Brett Creeley (2):
vfio/pds: Fix mutex lock->magic != lock warning vfio/pds: Fix possible sleep while in atomic context
drivers/vfio/pci/pds/pci_drv.c | 4 ++-- drivers/vfio/pci/pds/vfio_dev.c | 30 +++++++++++++++++++++--------- drivers/vfio/pci/pds/vfio_dev.h | 2 +- 3 files changed, 24 insertions(+), 12 deletions(-)
Signature · 1 line
2.17.1
Brett Creeley
maintainerPATCH v4 1/2 vfio/pds: Fix mutex lock->magic != lock warning
The following BUG was found when running on a kernel with CONFIG_DEBUG_MUTEXES=y set:
DEBUG_LOCKS_WARN_ON(lock->magic != lock)
RIP: 0010:mutex_trylock+0x10d/0x120 Call Trace: <TASK> ? __warn+0x85/0x140 ? mutex_trylock+0x10d/0x120 ? report_bug+0xfc/0x1e0 ? handle_bug+0x3f/0x70 ? exc_invalid_op+0x17/0x70 ? asm_exc_invalid_op+0x1a/0x20 ? mutex_trylock+0x10d/0x120 ? mutex_trylock+0x10d/0x120 pds_vfio_reset+0x3a/0x60 [pds_vfio_pci] pci_reset_function+0x4b/0x70 reset_store+0x5b/0xa0 kernfs_fop_write_iter+0x137/0x1d0 vfs_write+0x2de/0x410 ksys_write+0x5d/0xd0 do_syscall_64+0x3b/0x90 entry_SYSCALL_64_after_hwframe+0x6e/0xd8
As shown, lock->magic != lock. This is because mutex_init(&pds_vfio->state_mutex) is called in the VFIO open path. So, if a reset is initiated before the VFIO device is opened the mutex will have never been initialized. Fix this by calling mutex_init(&pds_vfio->state_mutex) in the VFIO init path.
Also, don't destroy the mutex on close because the device may be re-opened, which would cause mutex to be uninitialized. Fix this by implementing a driver specific vfio_device_ops.release callback that destroys the mutex before calling vfio_pci_core_release_dev().
--- drivers/vfio/pci/pds/vfio_dev.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
drivers/vfio/pci/pds/vfio_dev.c +13 -3
@@ -155,6 +155,8 @@ static int pds_vfio_init_device(struct vfio_device *vdev) pds_vfio->vf_id = vf_id; +mutex_init (&pds_vfio->state_mutex); + vdev->migration_flags =VFIO_MIGRATION_STOP_COPY |VFIO_MIGRATION_P2P ; vdev->mig_ops = &pds_vfio_lm_ops; vdev->log_ops = &pds_vfio_log_ops;
@@ -168,6 +170,16 @@ static int pds_vfio_init_device(struct vfio_device *vdev)return 0 ; } +static void pds_vfio_release_device (struct vfio_device *vdev) +{ +struct pds_vfio_pci_device *pds_vfio = + container_of(vdev, struct pds_vfio_pci_device, + vfio_coredev.vdev); + +mutex_destroy (&pds_vfio->state_mutex); +vfio_pci_core_release_dev (vdev); +} +static int pds_vfio_open_device (struct vfio_device *vdev) { struct pds_vfio_pci_device *pds_vfio =
@@ -179,7 +191,6 @@ static int pds_vfio_open_device(struct vfio_device *vdev)if (err)return err; -mutex_init (&pds_vfio->state_mutex); pds_vfio->state =VFIO_DEVICE_STATE_RUNNING ; pds_vfio->deferred_reset_state =VFIO_DEVICE_STATE_RUNNING ;
@@ -199,14 +210,13 @@ static void pds_vfio_close_device(struct vfio_device *vdev)pds_vfio_put_save_file (pds_vfio);pds_vfio_dirty_disable (pds_vfio, true);mutex_unlock (&pds_vfio->state_mutex); -mutex_destroy (&pds_vfio->state_mutex);vfio_pci_core_close_device (vdev); }static const struct vfio_device_ops pds_vfio_ops = { .name ="pds-vfio" , .init = pds_vfio_init_device, - .release = vfio_pci_core_release_dev, + .release = pds_vfio_release_device, .open_device = pds_vfio_open_device, .close_device = pds_vfio_close_device, .ioctl = vfio_pci_core_ioctl,
Signature · 1 line
2.17.1
Brett Creeley
maintainerPATCH v4 2/2 vfio/pds: Fix possible sleep while in atomic context
In reply to Brett CreeleyThe driver could possibly sleep while in atomic context resulting in the following call trace while CONFIG_DEBUG_ATOMIC_SLEEP=y is set:
BUG: sleeping function called from invalid context at kernel/locking/mutex.c:283 in_atomic(): 1, irqs_disabled(): 0, non_block: 0, pid: 2817, name: bash preempt_count: 1, expected: 0 RCU nest depth: 0, expected: 0 Call Trace: <TASK> dump_stack_lvl+0x36/0x50 __might_resched+0x123/0x170 mutex_lock+0x1e/0x50 pds_vfio_put_lm_file+0x1e/0xa0 [pds_vfio_pci] pds_vfio_put_save_file+0x19/0x30 [pds_vfio_pci] pds_vfio_state_mutex_unlock+0x2e/0x80 [pds_vfio_pci] pci_reset_function+0x4b/0x70 reset_store+0x5b/0xa0 kernfs_fop_write_iter+0x137/0x1d0 vfs_write+0x2de/0x410 ksys_write+0x5d/0xd0 do_syscall_64+0x3b/0x90 entry_SYSCALL_64_after_hwframe+0x6e/0xd8
This can happen if pds_vfio_put_restore_file() and/or pds_vfio_put_save_file() grab the mutex_lock(&lm_file->lock) while the spin_lock(&pds_vfio->reset_lock) is held, which can happen during while calling pds_vfio_state_mutex_unlock().
Fix this by changing the reset_lock to reset_mutex so there are no such conerns. Also, make sure to destroy the reset_mutex in the driver specific VFIO device release function.
This also fixes a spinlock bad magic BUG that was caused by not calling spinlock_init() on the reset_lock. Since, the lock is being changed to a mutex, make sure to call mutex_init() on it.
--- drivers/vfio/pci/pds/pci_drv.c | 4 ++-- drivers/vfio/pci/pds/vfio_dev.c | 14 ++++++++------ drivers/vfio/pci/pds/vfio_dev.h | 2 +- 3 files changed, 11 insertions(+), 9 deletions(-)
drivers/vfio/pci/pds/pci_drv.c +2 -2
@@ -55,10 +55,10 @@ static void pds_vfio_recovery(struct pds_vfio_pci_device *pds_vfio)* VFIO_DEVICE_STATE_RUNNING. */ if (deferred_reset_needed) { -spin_lock (&pds_vfio->reset_lock); +mutex_lock (&pds_vfio->reset_mutex); pds_vfio->deferred_reset = true; pds_vfio->deferred_reset_state =VFIO_DEVICE_STATE_ERROR ; -spin_unlock (&pds_vfio->reset_lock); +mutex_unlock (&pds_vfio->reset_mutex); } }
drivers/vfio/pci/pds/vfio_dev.c +8 -6
@@ -29,7 +29,7 @@ struct pds_vfio_pci_device *pds_vfio_pci_drvdata(struct pci_dev *pdev)void pds_vfio_state_mutex_unlock (struct pds_vfio_pci_device *pds_vfio) { again: -spin_lock (&pds_vfio->reset_lock); +mutex_lock (&pds_vfio->reset_mutex);if (pds_vfio->deferred_reset) { pds_vfio->deferred_reset = false;if (pds_vfio->state ==VFIO_DEVICE_STATE_ERROR ) {
@@ -39,23 +39,23 @@ void pds_vfio_state_mutex_unlock(struct pds_vfio_pci_device *pds_vfio) } pds_vfio->state = pds_vfio->deferred_reset_state; pds_vfio->deferred_reset_state =VFIO_DEVICE_STATE_RUNNING ; -spin_unlock (&pds_vfio->reset_lock); +mutex_unlock (&pds_vfio->reset_mutex); goto again; }mutex_unlock (&pds_vfio->state_mutex); -spin_unlock (&pds_vfio->reset_lock); +mutex_unlock (&pds_vfio->reset_mutex); }void pds_vfio_reset (struct pds_vfio_pci_device *pds_vfio) { -spin_lock (&pds_vfio->reset_lock); +mutex_lock (&pds_vfio->reset_mutex); pds_vfio->deferred_reset = true; pds_vfio->deferred_reset_state =VFIO_DEVICE_STATE_RUNNING ;if (!mutex_trylock (&pds_vfio->state_mutex)) { -spin_unlock (&pds_vfio->reset_lock); +mutex_unlock (&pds_vfio->reset_mutex);return ; } -spin_unlock (&pds_vfio->reset_lock); +mutex_unlock (&pds_vfio->reset_mutex);pds_vfio_state_mutex_unlock (pds_vfio); }
@@ -156,6 +156,7 @@ static int pds_vfio_init_device(struct vfio_device *vdev) pds_vfio->vf_id = vf_id;mutex_init (&pds_vfio->state_mutex); +mutex_init (&pds_vfio->reset_mutex); vdev->migration_flags =VFIO_MIGRATION_STOP_COPY |VFIO_MIGRATION_P2P ; vdev->mig_ops = &pds_vfio_lm_ops;
@@ -177,6 +178,7 @@ static void pds_vfio_release_device(struct vfio_device *vdev) vfio_coredev.vdev);mutex_destroy (&pds_vfio->state_mutex); +mutex_destroy (&pds_vfio->reset_mutex);vfio_pci_core_release_dev (vdev); }
drivers/vfio/pci/pds/vfio_dev.h +1 -1
@@ -18,7 +18,7 @@ struct pds_vfio_pci_device {struct pds_vfio_dirty dirty;struct mutex state_mutex;/* protect migration state */ enum vfio_device_mig_state state; -spinlock_t reset_lock;/* protect reset_done flow */ +struct mutex reset_mutex;/* protect reset_done flow */ u8 deferred_reset;enum vfio_device_mig_state deferred_reset_state;struct notifier_block nb;
Signature · 1 line
2.17.1
Alex Williamson
AppliedQuoted 27 lines · On Wed, 22 Nov 2023 11:25:30 -0800 Brett Creeley <[email protected]> wrote:
This series contains fixes for locking bugs in the recently introduced pds-vfio-pci driver. There was an initial bug reported by Dan Carpenter at:
https://lore.kernel.org/kvm/[email protected]/
However, more locking bugs were found when looking into the previously mentioned issue. So, all fixes are included in this series.
v4:
- Drop patch 1/3 since it added aspinlock_initthat was later replaced by amutex_initanywayv3:
https://lore.kernel.org/kvm/[email protected]/
- Change reset lock from spinlock to mutexv2:
https://lore.kernel.org/kvm/[email protected]/
- Trim the OOPs in the patch commit messages
- Rework patch 3/3 to only unlock the spinlock once
- Destroy thestate_mutexin the driver specific vfio_device_ops.release callback
Quoted 9 lines
Brett Creeley (2):
vfio/pds: Fix mutexlock->magic!= lock warning vfio/pds: Fix possible sleep while in atomic contextdrivers/vfio/pci/pds/pci_drv.c | 4 ++-- drivers/vfio/pci/pds/vfio_dev.c | 30 +++++++++++++++++++++--------- drivers/vfio/pci/pds/vfio_dev.h | 2 +- 3 files changed, 24 insertions(+), 12 deletions(-)
Applied to vfio for-linus branch for v6.7. Thanks,
Alex