KVM: extract lock_all_vcpus/unlock_all_vcpus
v2 cover KVM: extract lock_all_vcpus/unlock_all_vcpus
Implement Paolo's suggestion of reusing sev_lock/unlock_vcpus_for_migration in arm and riscv code for the purpose of taking vcpu->mutex of all vcpus of a VM.
Because sev_lock/unlock_vcpus_for_migration already have a workaround for lockdep max lock depth, this fixes the lockdep warnings on arm which were the inspiration for this refactoring.
This patch series was only compile tested on all 3 architectures.
V2: added trylock option to kvm_lock_all_vcpus to be better compatible with the orginal code.
Best regards,
Maxim Levitsky
Maxim Levitsky (4):
locking/mutex: implement mutex_trylock_nested
KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
KVM: arm64: switch to using kvm_lock/unlock_all_vcpus
RISC-V: KVM: switch to kvm_lock/unlock_all_vcpus
arch/arm64/include/asm/kvm_host.h | 3 -- arch/arm64/kvm/arch_timer.c | 4 +- arch/arm64/kvm/arm.c | 43 ---------------- arch/arm64/kvm/vgic/vgic-init.c | 4 +- arch/arm64/kvm/vgic/vgic-its.c | 8 +-- arch/arm64/kvm/vgic/vgic-kvm-device.c | 12 ++--- arch/riscv/kvm/aia_device.c | 34 +------------ arch/x86/kvm/svm/sev.c | 65 ++---------------------- include/linux/kvm_host.h | 6 +++ include/linux/mutex.h | 8 +++ kernel/locking/mutex.c | 14 ++++-- virt/kvm/kvm_main.c | 71 +++++++++++++++++++++++++++ 12 files changed, 116 insertions(+), 156 deletions(-)
Signature · 1 line
2.26.3
PATCH v2 1/4 locking/mutex: implement mutex_trylock_nested
Allow to specify the lockdep subclass in mutex_trylock instead of hardcoding it to 0.
--- include/linux/mutex.h | 8 ++++++++ kernel/locking/mutex.c | 14 +++++++++++--- 2 files changed, 19 insertions(+), 3 deletions(-)
include/linux/mutex.h +8 -0
@@ -193,7 +193,15 @@ extern void mutex_lock_io(struct mutex *lock);* * Returns 1 if the mutex has been acquired successfully, and 0 on contention. */ + +#ifdef CONFIG_DEBUG_LOCK_ALLOC +extern int mutex_trylock_nested (struct mutex *lock,unsigned int subclass); +#define mutex_trylock (lock) mutex_trylock_nested(lock, 0) +#else extern int mutex_trylock (struct mutex *lock); +#define mutex_trylock_nested (lock, subclass) mutex_trylock(lock) +#endif +extern void mutex_unlock (struct mutex *lock);extern int atomic_dec_and_mutex_lock (atomic_t *cnt,struct mutex *lock);
kernel/locking/mutex.c +11 -3
@@ -1062,6 +1062,7 @@ __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,#endif +#ifndef CONFIG_DEBUG_LOCK_ALLOC /** * mutex_trylock - try to acquire the mutex, without waiting * @lock: the mutex to be acquired
@@ -1077,18 +1078,25 @@ __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,* mutex must be released by the same task that acquired it. */ int __sched mutex_trylock(struct mutex *lock) +{ +MUTEX_WARN_ON (lock->magic != lock); +return __mutex_trylock (lock); +} +EXPORT_SYMBOL (mutex_trylock); +#else +int __sched mutex_trylock_nested(struct mutex *lock, unsigned int subclass) {bool locked;MUTEX_WARN_ON (lock->magic != lock); - locked =__mutex_trylock (lock);if (locked) -mutex_acquire (&lock->dep_map,0 ,1 , _RET_IP_); +mutex_acquire (&lock->dep_map, subclass,1 , _RET_IP_);return locked; } -EXPORT_SYMBOL (mutex_trylock); +EXPORT_SYMBOL (mutex_trylock_nested); +#endif #ifndef CONFIG_DEBUG_LOCK_ALLOC int __sched
Signature · 1 line
2.26.3
Peter Zijlstra
maintainerRe: [PATCH v2 1/4] locking/mutex: implement mutex_trylock_nested
Quoted 2 lines · Maxim Levitsky
Allow to specify the lockdep subclass in
mutex_trylockinstead of hardcoding it to 0.
We disable a whole bunch of checks for trylock, simply because they do not wait, therefore they cannot deadlock.
But I can't remember if they disable all the cases required to make subclasses completely redundant -- memory suggests they do, but I've not verified.
Please expand this Changelog to include definite proof that subclasses make sense with trylock.
PATCH v2 2/4 KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
In reply to Maxim LevitskyMove sev_lock/unlock_vcpus_for_migration to kvm_main and call the new functions the kvm_lock_all_vcpus/kvm_unlock_all_vcpus and kvm_lock_all_vcpus_nested.
This code allows to lock all vCPUs without triggering lockdep warning about reaching MAX_LOCK_DEPTH depth by coercing the lockdep into thinking that we release all the locks other than vcpu'0 lock immediately after we take them.
No functional change intended.
--- arch/x86/kvm/svm/sev.c | 65 +++--------------------------------- include/linux/kvm_host.h | 6 ++++ virt/kvm/kvm_main.c | 71 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 61 deletions(-)
arch/x86/kvm/svm/sev.c +4 -61
@@ -1889,63 +1889,6 @@ enum sev_migration_role { SEV_NR_MIGRATION_ROLES, }; -static int sev_lock_vcpus_for_migration (struct kvm *kvm, -enum sev_migration_role role) -{ -struct kvm_vcpu *vcpu; -unsigned long i, j; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (mutex_lock_killable_nested (&vcpu->mutex, role)) - goto out_unlock; - -#ifdef CONFIG_PROVE_LOCKING -if (!i) -/* -* Reset the role to one that avoids colliding with -* the role used for the first vcpu mutex. -*/ - role =SEV_NR_MIGRATION_ROLES ; -else -mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); -#endif - } - -return 0 ; - -out_unlock: - -kvm_for_each_vcpu (j, vcpu, kvm) { -if (i == j) -break ; - -#ifdef CONFIG_PROVE_LOCKING -if (j) -mutex_acquire (&vcpu->mutex.dep_map, role,0 , _THIS_IP_); -#endif - -mutex_unlock (&vcpu->mutex); - } -return -EINTR ; -} - -static void sev_unlock_vcpus_for_migration (struct kvm *kvm) -{ -struct kvm_vcpu *vcpu; -unsigned long i; -bool first = true; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (first) - first = false; -else -mutex_acquire (&vcpu->mutex.dep_map, -SEV_NR_MIGRATION_ROLES ,0 , _THIS_IP_); - -mutex_unlock (&vcpu->mutex); - } -} -static void sev_migrate_from (struct kvm *dst_kvm,struct kvm *src_kvm) {struct kvm_sev_info *dst =to_kvm_sev_info (dst_kvm);
@@ -2083,10 +2026,10 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) charged = true; } - ret =sev_lock_vcpus_for_migration (kvm,SEV_MIGRATION_SOURCE ); + ret =kvm_lock_all_vcpus_nested (kvm, false,SEV_MIGRATION_SOURCE );if (ret) goto out_dst_cgroup; - ret =sev_lock_vcpus_for_migration (source_kvm,SEV_MIGRATION_TARGET ); + ret =kvm_lock_all_vcpus_nested (source_kvm, false,SEV_MIGRATION_TARGET );if (ret) goto out_dst_vcpu;
@@ -2100,9 +2043,9 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) ret =0 ; out_source_vcpu: -sev_unlock_vcpus_for_migration (source_kvm); +kvm_unlock_all_vcpus (source_kvm); out_dst_vcpu: -sev_unlock_vcpus_for_migration (kvm); +kvm_unlock_all_vcpus (kvm); out_dst_cgroup:/* Operates on the source on success, on the destination on failure. */ if (charged)
include/linux/kvm_host.h +6 -0
@@ -1015,6 +1015,12 @@ static inline struct kvm_vcpu *kvm_get_vcpu_by_id(struct kvm *kvm, int id)void kvm_destroy_vcpus (struct kvm *kvm); +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role); +void kvm_unlock_all_vcpus (struct kvm *kvm); + +#define kvm_lock_all_vcpus (kvm, trylock) \ + kvm_lock_all_vcpus_nested(kvm, trylock, 0) +void vcpu_load (struct kvm_vcpu *vcpu);void vcpu_put (struct kvm_vcpu *vcpu);
virt/kvm/kvm_main.c +71 -0
77 lines not on this page · raw message
Signature · 1 line
2.26.3
Re: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
Quoted 156 lines · Maxim Levitsky
Move sev_lock/unlock_vcpus_for_migration to
kvm_mainand call the new functions the kvm_lock_all_vcpus/kvm_unlock_all_vcpus andkvm_lock_all_vcpus_nested.This code allows to lock all vCPUs without triggering lockdep warning about reaching
MAX_LOCK_DEPTHdepth by coercing the lockdep into thinking that we release all the locks other than vcpu'0 lock immediately after we take them.No functional change intended.
Suggested-by Paolo Bonzini <[email protected]>Signed-off-by Maxim Levitsky <[email protected]>--- arch/x86/kvm/svm/sev.c | 65 +++--------------------------------- include/linux/kvm_host.h | 6 ++++ virt/kvm/kvm_main.c | 71 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 61 deletions(-)arch/x86/kvm/svm/sev.c +4
-61@@ -1889,63 +1889,6 @@ enum sev_migration_role { SEV_NR_MIGRATION_ROLES, }; -static int sev_lock_vcpus_for_migration (struct kvm *kvm, -enum sev_migration_role role) -{ -struct kvm_vcpu *vcpu; -unsigned long i, j; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (mutex_lock_killable_nested (&vcpu->mutex, role)) - goto out_unlock; - -#ifdef CONFIG_PROVE_LOCKING -if (!i) -/* -* Reset the role to one that avoids colliding with -* the role used for the first vcpu mutex. -*/ - role =SEV_NR_MIGRATION_ROLES ; -else -mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); -#endif - } - -return 0 ; - -out_unlock: - -kvm_for_each_vcpu (j, vcpu, kvm) { -if (i == j) -break ; - -#ifdef CONFIG_PROVE_LOCKING -if (j) -mutex_acquire (&vcpu->mutex.dep_map, role,0 , _THIS_IP_); -#endif - -mutex_unlock (&vcpu->mutex); - } -return -EINTR ; -} - -static void sev_unlock_vcpus_for_migration (struct kvm *kvm) -{ -struct kvm_vcpu *vcpu; -unsigned long i; -bool first = true; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (first) - first = false; -else -mutex_acquire (&vcpu->mutex.dep_map, -SEV_NR_MIGRATION_ROLES ,0 , _THIS_IP_); - -mutex_unlock (&vcpu->mutex); - } -} -static void sev_migrate_from (struct kvm *dst_kvm,struct kvm *src_kvm) {struct kvm_sev_info *dst =to_kvm_sev_info (dst_kvm);@@ -2083,10 +2026,10 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) charged = true; } - ret =sev_lock_vcpus_for_migration (kvm,SEV_MIGRATION_SOURCE ); + ret =kvm_lock_all_vcpus_nested (kvm, false,SEV_MIGRATION_SOURCE );if (ret) goto out_dst_cgroup; - ret =sev_lock_vcpus_for_migration (source_kvm,SEV_MIGRATION_TARGET ); + ret =kvm_lock_all_vcpus_nested (source_kvm, false,SEV_MIGRATION_TARGET );if (ret) goto out_dst_vcpu;@@ -2100,9 +2043,9 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) ret =0 ; out_source_vcpu: -sev_unlock_vcpus_for_migration (source_kvm); +kvm_unlock_all_vcpus (source_kvm); out_dst_vcpu: -sev_unlock_vcpus_for_migration (kvm); +kvm_unlock_all_vcpus (kvm); out_dst_cgroup:/* Operates on the source on success, on the destination on failure. */ if (charged)include/linux/kvm_host.h +6
-0@@ -1015,6 +1015,12 @@ static inline struct kvm_vcpu *kvm_get_vcpu_by_id(struct kvm *kvm, int id)void kvm_destroy_vcpus (struct kvm *kvm); +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role); +void kvm_unlock_all_vcpus (struct kvm *kvm); + +#define kvm_lock_all_vcpus (kvm, trylock) \ + kvm_lock_all_vcpus_nested(kvm, trylock, 0) +void vcpu_load (struct kvm_vcpu *vcpu);void vcpu_put (struct kvm_vcpu *vcpu);virt/kvm/kvm_main.c +19
-0@@ -1368,6 +1368,77 @@ static int kvm_vm_release(struct inode *inode, struct file *filp)return 0 ; } + +/* +* Lock all VM vCPUs. +* Can be used nested (to lock vCPUS of two VMs for example) +*/ +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role) +{ +struct kvm_vcpu *vcpu; +unsigned long i, j; + +lockdep_assert_held (&kvm->lock); + +kvm_for_each_vcpu (i, vcpu, kvm) { + +if (trylock && !mutex_trylock_nested (&vcpu->mutex, role)) + goto out_unlock; +else if (!trylock &&mutex_lock_killable_nested (&vcpu->mutex, role)) + goto out_unlock; +
virt/kvm/kvm_main.c static int kvm_vm_release(struct inode *inode, struct file *filp) · line 1399
Quoted 10 lines
virt/kvm/kvm_main.c +10
-0+#ifdef CONFIG_PROVE_LOCKING +if (!i) +/* +* Reset the role to one that avoids colliding with +* the role used for the first vcpu mutex. +*/ + role =MAX_LOCK_DEPTH -1 ; +else +mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); +#endif
Lockdep supports up to 8 subclasses, but MAX_LOCK_DEPTH is 48. I believe it is OK to add a mutex_trylock_nested(), but can you just use 0 and 1 for the subclasses?
Cheers,
Longman
Re: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
In reply to Maxim LevitskyQuoted 117 lines · Maxim Levitsky
Move sev_lock/unlock_vcpus_for_migration to
kvm_mainand call the new functions the kvm_lock_all_vcpus/kvm_unlock_all_vcpus andkvm_lock_all_vcpus_nested.This code allows to lock all vCPUs without triggering lockdep warning about reaching
MAX_LOCK_DEPTHdepth by coercing the lockdep into thinking that we release all the locks other than vcpu'0 lock immediately after we take them.No functional change intended.
Suggested-by Paolo Bonzini <[email protected]>Signed-off-by Maxim Levitsky <[email protected]>--- arch/x86/kvm/svm/sev.c | 65 +++--------------------------------- include/linux/kvm_host.h | 6 ++++ virt/kvm/kvm_main.c | 71 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 61 deletions(-)arch/x86/kvm/svm/sev.c +4
-61@@ -1889,63 +1889,6 @@ enum sev_migration_role { SEV_NR_MIGRATION_ROLES, }; -static int sev_lock_vcpus_for_migration (struct kvm *kvm, -enum sev_migration_role role) -{ -struct kvm_vcpu *vcpu; -unsigned long i, j; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (mutex_lock_killable_nested (&vcpu->mutex, role)) - goto out_unlock; - -#ifdef CONFIG_PROVE_LOCKING -if (!i) -/* -* Reset the role to one that avoids colliding with -* the role used for the first vcpu mutex. -*/ - role =SEV_NR_MIGRATION_ROLES ; -else -mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); -#endif - } - -return 0 ; - -out_unlock: - -kvm_for_each_vcpu (j, vcpu, kvm) { -if (i == j) -break ; - -#ifdef CONFIG_PROVE_LOCKING -if (j) -mutex_acquire (&vcpu->mutex.dep_map, role,0 , _THIS_IP_); -#endif - -mutex_unlock (&vcpu->mutex); - } -return -EINTR ; -} - -static void sev_unlock_vcpus_for_migration (struct kvm *kvm) -{ -struct kvm_vcpu *vcpu; -unsigned long i; -bool first = true; - -kvm_for_each_vcpu (i, vcpu, kvm) { -if (first) - first = false; -else -mutex_acquire (&vcpu->mutex.dep_map, -SEV_NR_MIGRATION_ROLES ,0 , _THIS_IP_); - -mutex_unlock (&vcpu->mutex); - } -} -static void sev_migrate_from (struct kvm *dst_kvm,struct kvm *src_kvm) {struct kvm_sev_info *dst =to_kvm_sev_info (dst_kvm);@@ -2083,10 +2026,10 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) charged = true; } - ret =sev_lock_vcpus_for_migration (kvm,SEV_MIGRATION_SOURCE ); + ret =kvm_lock_all_vcpus_nested (kvm, false,SEV_MIGRATION_SOURCE );if (ret) goto out_dst_cgroup; - ret =sev_lock_vcpus_for_migration (source_kvm,SEV_MIGRATION_TARGET ); + ret =kvm_lock_all_vcpus_nested (source_kvm, false,SEV_MIGRATION_TARGET );if (ret) goto out_dst_vcpu;@@ -2100,9 +2043,9 @@ int sev_vm_move_enc_context_from(struct kvm *kvm, unsigned int source_fd) ret =0 ; out_source_vcpu: -sev_unlock_vcpus_for_migration (source_kvm); +kvm_unlock_all_vcpus (source_kvm); out_dst_vcpu: -sev_unlock_vcpus_for_migration (kvm); +kvm_unlock_all_vcpus (kvm); out_dst_cgroup:/* Operates on the source on success, on the destination on failure. */ if (charged)include/linux/kvm_host.h +0
-0
include/linux/kvm_host.h static inline struct kvm_vcpu *kvm_get_vcpu_by_id(struct kvm *kvm, int id) · line 1023
Quoted 9 lines
include/linux/kvm_host.h +6
-0@@ -1015,6 +1015,12 @@ static inline struct kvm_vcpu *kvm_get_vcpu_by_id(struct kvm *kvm, int id)void kvm_destroy_vcpus (struct kvm *kvm); +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role); +void kvm_unlock_all_vcpus (struct kvm *kvm); + +#define kvm_lock_all_vcpus (kvm, trylock) \ + kvm_lock_all_vcpus_nested(kvm, trylock, 0) +
Can you instead add lock / trylock variants of this?
kvm_trylock_all_vcpus(kvm) seems a bit more obvious in the calling code.
Thanks,
Oliver
Peter Zijlstra
maintainerRe: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
In reply to Maxim LevitskyQuoted 28 lines · Maxim Levitsky
virt/kvm/kvm_main.c +20
-0@@ -1368,6 +1368,77 @@ static int kvm_vm_release(struct inode *inode, struct file *filp)return 0 ; } + +/* +* Lock all VM vCPUs. +* Can be used nested (to lock vCPUS of two VMs for example) +*/ +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role) +{ +struct kvm_vcpu *vcpu; +unsigned long i, j; + +lockdep_assert_held (&kvm->lock); + +kvm_for_each_vcpu (i, vcpu, kvm) { + +if (trylock && !mutex_trylock_nested (&vcpu->mutex, role)) + goto out_unlock; +else if (!trylock &&mutex_lock_killable_nested (&vcpu->mutex, role)) + goto out_unlock; + +#ifdef CONFIG_PROVE_LOCKING
virt/kvm/kvm_main.c static int kvm_vm_release(struct inode *inode, struct file *filp) · line 1400
Quoted 10 lines
virt/kvm/kvm_main.c +10
-0+if (!i) +/* +* Reset the role to one that avoids colliding with +* the role used for the first vcpu mutex. +*/ + role =MAX_LOCK_DEPTH -1 ; +else +mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); +#endif + }
This code is all sorts of terrible.
Per the lockdep_assert_held() above, you serialize all these locks by holding that lock, this means you can be using the _nest_lock() annotation.
Also, the original code didn't have this trylock nonsense, and the Changelog doesn't mention this -- in fact the Changelog claims no change, which is patently false.
Anyway, please write like:
kvm_for_each_vcpu(i, vcpu, kvm) {
if (mutex_lock_killable_nest_lock(&vcpu->mutex, &kvm->lock))
goto unlock;
}
return 0;unlock:
kvm_for_each_vcpu(j, vcpu, kvm) {
if (j == i)
break;
mutex_unlock(&vcpu->mutex);
}
return -EINTR;And yes, you'll have to add mutex_lock_killable_nest_lock(), but that should be trivial.
Paolo Bonzini
maintainerRe: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
Quoted 69 lines · Peter Zijlstra
Quoted 28 lines · Maxim Levitsky
virt/kvm/kvm_main.c +20
-0@@ -1368,6 +1368,77 @@ static int kvm_vm_release(struct inode *inode, struct file *filp)return 0 ; } + +/* +* Lock all VM vCPUs. +* Can be used nested (to lock vCPUS of two VMs for example) +*/ +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role) +{ +struct kvm_vcpu *vcpu; +unsigned long i, j; + +lockdep_assert_held (&kvm->lock); + +kvm_for_each_vcpu (i, vcpu, kvm) { + +if (trylock && !mutex_trylock_nested (&vcpu->mutex, role)) + goto out_unlock; +else if (!trylock &&mutex_lock_killable_nested (&vcpu->mutex, role)) + goto out_unlock; + +#ifdef CONFIG_PROVE_LOCKING virt/kvm/kvm_main.c static int kvm_vm_release(struct inode *inode, struct file *filp) · line 1400
Quoted 10 lines
virt/kvm/kvm_main.c +10
-0+if (!i) +/* +* Reset the role to one that avoids colliding with +* the role used for the first vcpu mutex. +*/ + role =MAX_LOCK_DEPTH -1 ; +else +mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); +#endif + }This code is all sorts of terrible.
Per the
lockdep_assert_held()above, you serialize all these locks by holding that lock, this means you can be using the_nest_lock()annotation.Also, the original code didn't have this trylock nonsense, and the Changelog doesn't mention this -- in fact the Changelog claims no change, which is patently false.
Anyway, please write like:
kvm_for_each_vcpu(i, vcpu, kvm) { if (mutex_lock_killable_nest_lock(&vcpu->mutex, &kvm->lock)) goto unlock; } return 0;unlock:
kvm_for_each_vcpu(j, vcpu, kvm) { if (j == i) break; mutex_unlock(&vcpu->mutex); } return -EINTR;
Quoted 2 lines
And yes, you'll have to add
mutex_lock_killable_nest_lock(), but that should be trivial.
If I understand correctly, that would be actually _mutex_lock_killable_nest_lock() plus a wrapper macro. But yes, that is easy so it sounds good.
For the ARM case, which is the actual buggy one (it was complaining about too high a depth) it still needs mutex_trylock_nest_lock(); the nest_lock is needed to avoid bumping the depth on every mutex_trylock().
It should be something like
include/linux/mutex.h +13 -1
@@ -174,6 +174,12 @@ do { \_mutex_lock_nest_lock (lock, &(nest_lock)->dep_map); \ } while (0) +#define mutex_trylock_nest_lock (lock, nest_lock) \ +do { \ + typecheck(struct lockdep_map *, &(nest_lock)->dep_map); \ + _mutex_trylock_nest_lock(lock, &(nest_lock)->dep_map); \ +} while (0) +#else extern void mutex_lock (struct mutex *lock);extern int __must_check mutex_lock_interruptible (struct mutex *lock);
@@ -185,6 +191,7 @@ extern void mutex_lock_io(struct mutex *lock);# define mutex_lock_killable_nested (lock, subclass) mutex_lock_killable(lock)# define mutex_lock_nest_lock (lock, nest_lock) mutex_lock(lock)# define mutex_lock_io_nested (lock, subclass) mutex_lock_io(lock) +# define mutex_trylock_nest_lock (lock, nest_lock) mutex_trylock(lock)#endif /*
@@ -193,9 +200,14 @@ extern void mutex_lock_io(struct mutex *lock);* * Returns 1 if the mutex has been acquired successfully, and 0 on contention. */ -extern int mutex_trylock (struct mutex *lock); +extern int _mutex_trylock_nest_lock (struct mutex *lock,struct lockdep_map *nest_lock);extern void mutex_unlock (struct mutex *lock); +static inline int mutex_trylock (struct mutex *lock) +{ +return _mutex_trylock_nest_lock (lock,NULL ); +} +extern int atomic_dec_and_mutex_lock (atomic_t *cnt,struct mutex *lock); DEFINE_GUARD(mutex, struct mutex *, mutex_lock(_T), mutex_unlock(_T))
kernel/locking/mutex.c +6 -4
@@ -1063,8 +1063,10 @@ __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,#endif /** -* mutex_trylock - try to acquire the mutex, without waiting +* _mutex_trylock_nest_lock - try to acquire the mutex, without waiting * @lock: the mutex to be acquired +* @nest_lock: if not NULL, a mutex that is always taken whenever multiple +* instances of @lock are * * Try to acquire the mutex atomically. Returns 1 if the mutex * has been acquired successfully, and 0 on contention.
@@ -1076,7 +1078,7 @@ __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,* This function must not be used in interrupt context. The * mutex must be released by the same task that acquired it. */ -int __sched mutex_trylock(struct mutex *lock) +int __sched _mutex_trylock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock) {bool locked;
@@ -1084,11 +1086,11 @@ int __sched mutex_trylock(struct mutex *lock) locked =__mutex_trylock (lock);if (locked) -mutex_acquire (&lock->dep_map,0 ,1 , _RET_IP_); +mutex_acquire_nest (&lock->dep_map,0 ,1 , nest_lock, _RET_IP_);return locked; } -EXPORT_SYMBOL (mutex_trylock); +EXPORT_SYMBOL (_mutex_trylock_nest_lock);#ifndef CONFIG_DEBUG_LOCK_ALLOC int __sched
Does that seem sane?
Paolo
Peter Zijlstra
maintainerRe: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
Quoted 72 lines · Paolo Bonzini
Quoted 68 lines · Peter Zijlstra
Quoted 27 lines · Maxim Levitsky
virt/kvm/kvm_main.c +20
-0@@ -1368,6 +1368,77 @@ static int kvm_vm_release(struct inode *inode, struct file *filp)return 0 ; } + +/* +* Lock all VM vCPUs. +* Can be used nested (to lock vCPUS of two VMs for example) +*/ +int kvm_lock_all_vcpus_nested (struct kvm *kvm,bool trylock,unsigned int role) +{ +struct kvm_vcpu *vcpu; +unsigned long i, j; + +lockdep_assert_held (&kvm->lock); + +kvm_for_each_vcpu (i, vcpu, kvm) { + +if (trylock && !mutex_trylock_nested (&vcpu->mutex, role)) + goto out_unlock; +else if (!trylock &&mutex_lock_killable_nested (&vcpu->mutex, role)) + goto out_unlock; + +#ifdef CONFIG_PROVE_LOCKING virt/kvm/kvm_main.c static int kvm_vm_release(struct inode *inode, struct file *filp) · line 1399
Quoted 10 lines
virt/kvm/kvm_main.c +10
-0+if (!i) +/* +* Reset the role to one that avoids colliding with +* the role used for the first vcpu mutex. +*/ + role =MAX_LOCK_DEPTH -1 ; +else +mutex_release (&vcpu->mutex.dep_map, _THIS_IP_); +#endif + }This code is all sorts of terrible.
Per the
lockdep_assert_held()above, you serialize all these locks by holding that lock, this means you can be using the_nest_lock()annotation.Also, the original code didn't have this trylock nonsense, and the Changelog doesn't mention this -- in fact the Changelog claims no change, which is patently false.
Anyway, please write like:
kvm_for_each_vcpu(i, vcpu, kvm) { if (mutex_lock_killable_nest_lock(&vcpu->mutex, &kvm->lock)) goto unlock; } return 0;unlock:
kvm_for_each_vcpu(j, vcpu, kvm) { if (j == i) break; mutex_unlock(&vcpu->mutex); } return -EINTR;Quoted 2 lines
And yes, you'll have to add
mutex_lock_killable_nest_lock(), but that should be trivial.
Quoted 8 lines
If I understand correctly, that would be actually
_mutex_lock_killable_nest_lock()plus a wrapper macro. But yes, that is easy so it sounds good.For the ARM case, which is the actual buggy one (it was complaining about too high a depth) it still needs
mutex_trylock_nest_lock(); thenest_lockis needed to avoid bumping the depth on everymutex_trylock().
Got a link to the ARM code in question ? And I'm assuming you're talking about task_struct::lockdep_depth ? The nest lock annotation does not in fact increment depth beyond one of each type. It does a refcount like thing.
Paolo Bonzini
maintainerRe: [PATCH v2 2/4] KVM: x86: move sev_lock/unlock_vcpus_for_migration to kvm_main.c
Quoted 6 lines · Peter Zijlstra
Quoted 4 lines
For the ARM case, which is the actual buggy one (it was complaining about too high a depth) it still needs
mutex_trylock_nest_lock(); thenest_lockis needed to avoid bumping the depth on everymutex_trylock().Got a link to the ARM code in question ?
lock_all_vcpus() in arch/arm64/kvm/arm.c:
lockdep_assert_held(&kvm->lock);
kvm_for_each_vcpu(c, tmp_vcpu, kvm) {
if (!mutex_trylock(&tmp_vcpu->mutex)) {
unlock_vcpus(kvm, c - 1);
return false;
}
}Quoted 3 lines
And I'm assuming you're talking about
task_struct::lockdep_depth? The nest lock annotation does not in fact increment depth beyond one of each type. It does a refcount like thing.
Yes, exactly - mutex_trylock_nest_lock() is needed so that the code above counts per-lock instead of using the per-task depth.
Paolo
PATCH v2 3/4 KVM: arm64: switch to using kvm_lock/unlock_all_vcpus
In reply to Maxim LevitskySwitch to kvm_lock/unlock_all_vcpus instead of arm's own version.
This fixes lockdep warning about reaching maximum lock depth:
[ 328.171264] BUG: MAX_LOCK_DEPTH too low!
[ 328.175227] turning off the locking correctness validator.
[ 328.180726] Please attach the output of /proc/lock_stat to the bug report
[ 328.187531] depth: 48 max: 48!
[ 328.190678] 48 locks held by qemu-kvm/11664:
[ 328.194957] #0: ffff800086de5ba0 (&kvm->lock){+.+.}-{3:3}, at: kvm_ioctl_create_device+0x174/0x5b0
[ 328.204048] #1: ffff0800e78800b8 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0
[ 328.212521] #2: ffff07ffeee51e98 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0
[ 328.220991] #3: ffff0800dc7d80b8 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0
[ 328.229463] #4: ffff07ffe0c980b8 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0
[ 328.237934] #5: ffff0800a3883c78 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0
[ 328.246405] #6: ffff07fffbe480b8 (&vcpu->mutex){+.+.}-{3:3}, at: lock_all_vcpus+0x16c/0x2a0--- arch/arm64/include/asm/kvm_host.h | 3 -- arch/arm64/kvm/arch_timer.c | 4 +-- arch/arm64/kvm/arm.c | 43 --------------------------- arch/arm64/kvm/vgic/vgic-init.c | 4 +-- arch/arm64/kvm/vgic/vgic-its.c | 8 ++--- arch/arm64/kvm/vgic/vgic-kvm-device.c | 12 ++++---- 6 files changed, 14 insertions(+), 60 deletions(-)
arch/arm64/include/asm/kvm_host.h +0 -3
@@ -1263,9 +1263,6 @@ int __init populate_sysreg_config(const struct sys_reg_desc *sr, unsigned int idx);int __init populate_nv_trap_config (void ); -bool lock_all_vcpus (struct kvm *kvm); -void unlock_all_vcpus (struct kvm *kvm); -void kvm_calculate_traps (struct kvm_vcpu *vcpu);/* MMIO helpers */
arch/arm64/kvm/arch_timer.c +2 -2
@@ -1766,7 +1766,7 @@ int kvm_vm_ioctl_set_counter_offset(struct kvm *kvm,mutex_lock (&kvm->lock); -if (lock_all_vcpus (kvm)) { +if (!kvm_lock_all_vcpus (kvm, true)) {set_bit (KVM_ARCH_FLAG_VM_COUNTER_OFFSET , &kvm->arch.flags);/*
@@ -1778,7 +1778,7 @@ int kvm_vm_ioctl_set_counter_offset(struct kvm *kvm, kvm->arch.timer_data.voffset = offset->counter_offset; kvm->arch.timer_data.poffset = offset->counter_offset; -unlock_all_vcpus (kvm); +kvm_unlock_all_vcpus (kvm); }else { ret = -EBUSY ; }
arch/arm64/kvm/arm.c +0 -43
49 lines not on this page · raw message
arch/arm64/kvm/vgic/vgic-init.c +2 -2
@@ -88,7 +88,7 @@ int kvm_vgic_create(struct kvm *kvm, u32 type)lockdep_assert_held (&kvm->lock); ret = -EBUSY ; -if (!lock_all_vcpus (kvm)) +if (kvm_lock_all_vcpus (kvm, true))return ret;mutex_lock (&kvm->arch.config_lock);
@@ -142,7 +142,7 @@ int kvm_vgic_create(struct kvm *kvm, u32 type) out_unlock:mutex_unlock (&kvm->arch.config_lock); -unlock_all_vcpus (kvm); +kvm_unlock_all_vcpus (kvm);return ret; }
arch/arm64/kvm/vgic/vgic-its.c +4 -4
@@ -1999,7 +1999,7 @@ static int vgic_its_attr_regs_access(struct kvm_device *dev,mutex_lock (&dev->kvm->lock); -if (!lock_all_vcpus (dev->kvm)) { +if (kvm_lock_all_vcpus (dev->kvm, true)) {mutex_unlock (&dev->kvm->lock);return -EBUSY ; }
@@ -2034,7 +2034,7 @@ static int vgic_its_attr_regs_access(struct kvm_device *dev, } out:mutex_unlock (&dev->kvm->arch.config_lock); -unlock_all_vcpus (dev->kvm); +kvm_unlock_all_vcpus (dev->kvm);mutex_unlock (&dev->kvm->lock);return ret; }
@@ -2704,7 +2704,7 @@ static int vgic_its_ctrl(struct kvm *kvm, struct vgic_its *its, u64 attr)mutex_lock (&kvm->lock); -if (!lock_all_vcpus (kvm)) { +if (kvm_lock_all_vcpus (kvm, true)) {mutex_unlock (&kvm->lock);return -EBUSY ; }
@@ -2726,7 +2726,7 @@ static int vgic_its_ctrl(struct kvm *kvm, struct vgic_its *its, u64 attr)mutex_unlock (&its->its_lock);mutex_unlock (&kvm->arch.config_lock); -unlock_all_vcpus (kvm); +kvm_unlock_all_vcpus (kvm);mutex_unlock (&kvm->lock);return ret; }
arch/arm64/kvm/vgic/vgic-kvm-device.c +6 -6
@@ -268,7 +268,7 @@ static int vgic_set_common_attr(struct kvm_device *dev,return -ENXIO ;mutex_lock (&dev->kvm->lock); -if (!lock_all_vcpus (dev->kvm)) { +if (kvm_lock_all_vcpus (dev->kvm, true)) {mutex_unlock (&dev->kvm->lock);return -EBUSY ; }
@@ -276,7 +276,7 @@ static int vgic_set_common_attr(struct kvm_device *dev,mutex_lock (&dev->kvm->arch.config_lock); r =vgic_v3_save_pending_tables (dev->kvm);mutex_unlock (&dev->kvm->arch.config_lock); -unlock_all_vcpus (dev->kvm); +kvm_unlock_all_vcpus (dev->kvm);mutex_unlock (&dev->kvm->lock);return r; }
@@ -390,7 +390,7 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev,mutex_lock (&dev->kvm->lock); -if (!lock_all_vcpus (dev->kvm)) { +if (kvm_lock_all_vcpus (dev->kvm, true)) {mutex_unlock (&dev->kvm->lock);return -EBUSY ; }
@@ -415,7 +415,7 @@ static int vgic_v2_attr_regs_access(struct kvm_device *dev, out:mutex_unlock (&dev->kvm->arch.config_lock); -unlock_all_vcpus (dev->kvm); +kvm_unlock_all_vcpus (dev->kvm);mutex_unlock (&dev->kvm->lock);if (!ret && !is_write)
@@ -554,7 +554,7 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev,mutex_lock (&dev->kvm->lock); -if (!lock_all_vcpus (dev->kvm)) { +if (kvm_lock_all_vcpus (dev->kvm, true)) {mutex_unlock (&dev->kvm->lock);return -EBUSY ; }
@@ -611,7 +611,7 @@ static int vgic_v3_attr_regs_access(struct kvm_device *dev, out:mutex_unlock (&dev->kvm->arch.config_lock); -unlock_all_vcpus (dev->kvm); +kvm_unlock_all_vcpus (dev->kvm);mutex_unlock (&dev->kvm->lock);if (!ret && uaccess && !is_write) {
Signature · 1 line
2.26.3
PATCH v2 4/4 RISC-V: KVM: switch to kvm_lock/unlock_all_vcpus
In reply to Maxim Levitskyuse kvm_lock/unlock_all_vcpus instead of riscv's own implementation.
Note that this does introduce a slight functional change - now vCPUs are unlocked in the same order they were locked and not in the opposite order.
--- arch/riscv/kvm/aia_device.c | 34 ++-------------------------------- 1 file changed, 2 insertions(+), 32 deletions(-)
arch/riscv/kvm/aia_device.c +2 -32
@@ -12,36 +12,6 @@#include <linux/kvm_host.h> #include <linux/uaccess.h> -static void unlock_vcpus (struct kvm *kvm,int vcpu_lock_idx) -{ -struct kvm_vcpu *tmp_vcpu; - -for (; vcpu_lock_idx >=0 ; vcpu_lock_idx--) { - tmp_vcpu =kvm_get_vcpu (kvm, vcpu_lock_idx); -mutex_unlock (&tmp_vcpu->mutex); - } -} - -static void unlock_all_vcpus (struct kvm *kvm) -{ -unlock_vcpus (kvm,atomic_read (&kvm->online_vcpus) -1 ); -} - -static bool lock_all_vcpus (struct kvm *kvm) -{ -struct kvm_vcpu *tmp_vcpu; -unsigned long c; - -kvm_for_each_vcpu (c, tmp_vcpu, kvm) { -if (!mutex_trylock (&tmp_vcpu->mutex)) { -unlock_vcpus (kvm, c -1 ); -return false; - } - } - -return true; -} -static int aia_create (struct kvm_device *dev,u32 type) {int ret;
@@ -53,7 +23,7 @@ static int aia_create(struct kvm_device *dev, u32 type)return -EEXIST ; ret = -EBUSY ; -if (!lock_all_vcpus (kvm)) +if (kvm_lock_all_vcpus (kvm, true))return ret;kvm_for_each_vcpu (i, vcpu, kvm) {
@@ -65,7 +35,7 @@ static int aia_create(struct kvm_device *dev, u32 type) kvm->arch.aia.in_kernel = true; out_unlock: -unlock_all_vcpus (kvm); +kvm_unlock_all_vcpus (kvm);return ret; }
Signature · 1 line
2.26.3
Sean Christopherson
maintainer+Adrian
Quoted 1 line · Maxim Levitsky
Implement Paolo's suggestion of reusing
Ha! I *knew* this felt familiar when I suggested extracting (un)lock_all_vcpus() to common code in the context of the TDX series.
https://lore.kernel.org/all/[email protected]
Quoted 39 lines
sev_lock/unlock_vcpus_for_migration in arm and riscv code for the purpose of taking
vcpu->mutexof all vcpus of a VM.Because sev_lock/unlock_vcpus_for_migration already have a workaround for lockdep max lock depth, this fixes the lockdep warnings on arm which were the inspiration for this refactoring.
This patch series was only compile tested on all 3 architectures.
V2: added trylock option to
kvm_lock_all_vcpusto be better compatible with the orginal code.Best regards,
Maxim LevitskyMaxim Levitsky (4):
locking/mutex: implementmutex_trylock_nested
KVM: x86: move sev_lock/unlock_vcpus_for_migration tokvm_main.c
KVM: arm64: switch to using kvm_lock/unlock_all_vcpus
RISC-V: KVM: switch to kvm_lock/unlock_all_vcpusarch/arm64/include/asm/kvm_host.h | 3 -- arch/arm64/kvm/arch_timer.c | 4 +- arch/arm64/kvm/arm.c | 43 ---------------- arch/arm64/kvm/vgic/vgic-init.c | 4 +- arch/arm64/kvm/vgic/vgic-its.c | 8 +-- arch/arm64/kvm/vgic/vgic-kvm-device.c | 12 ++--- arch/riscv/kvm/aia_device.c | 34 +------------ arch/x86/kvm/svm/sev.c | 65 ++---------------------- include/linux/kvm_host.h | 6 +++ include/linux/mutex.h | 8 +++ kernel/locking/mutex.c | 14 ++++-- virt/kvm/kvm_main.c | 71 +++++++++++++++++++++++++++ 12 files changed, 116 insertions(+), 156 deletions(-)Signature · 1 line
2.26.3