| Message ID | 20210603164315.682994-1-senozhatsky@chromium.org (mailing list archive) |
|---|---|
| State | RFC |
| Headers | show |
| Series | [RFC] kvm: add suspend pm-notifier | expand |
On Fri, Jun 04, 2021 at 01:43:15AM +0900, Sergey Senozhatsky wrote: > Add KVM suspend/hibernate PM-notifier which lets architectures > to implement arch-specific VM suspend code. For instance, on x86 > this sets PVCLOCK_GUEST_STOPPED on all the VCPUs. > > Our case is that user puts the host system into sleep multiple > times a day (e.g. closes the laptop's lid) so we need a reliable > way to suspend VMs properly. > > Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org> > --- > arch/arm64/kvm/arm.c | 4 ++++ > arch/mips/kvm/mips.c | 4 ++++ > arch/powerpc/kvm/powerpc.c | 4 ++++ > arch/s390/kvm/kvm-s390.c | 4 ++++ > arch/x86/kvm/x86.c | 21 ++++++++++++++++++++ > include/linux/kvm_host.h | 8 ++++++++ > virt/kvm/kvm_main.c | 40 ++++++++++++++++++++++++++++++++++++++ > 7 files changed, 85 insertions(+) > > diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c > index 1126eae27400..547dbe44d039 100644 > --- a/arch/arm64/kvm/arm.c > +++ b/arch/arm64/kvm/arm.c > @@ -1311,6 +1311,10 @@ static int kvm_vm_ioctl_set_device_addr(struct kvm *kvm, > } > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c > index 4d4af97dcc88..d4408acd2be6 100644 > --- a/arch/mips/kvm/mips.c > +++ b/arch/mips/kvm/mips.c > @@ -980,6 +980,10 @@ void kvm_arch_flush_remote_tlbs_memslot(struct kvm *kvm, > kvm_flush_remote_tlbs(kvm); > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) > { > long r; > diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c > index a2a68a958fa0..96e8a7b6fcf0 100644 > --- a/arch/powerpc/kvm/powerpc.c > +++ b/arch/powerpc/kvm/powerpc.c > @@ -2334,6 +2334,10 @@ static int kvmppc_get_cpu_char(struct kvm_ppc_cpu_char *cp) > } > #endif > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c > index 1296fc10f80c..c5f86fc1e497 100644 > --- a/arch/s390/kvm/kvm-s390.c > +++ b/arch/s390/kvm/kvm-s390.c > @@ -2367,6 +2367,10 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) > return r; > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { What looks like you wants a __weak function.
On (21/06/03 19:27), Peter Zijlstra wrote: > On Fri, Jun 04, 2021 at 01:43:15AM +0900, Sergey Senozhatsky wrote: [..] > > > > +void kvm_arch_pm_notifier(struct kvm *kvm) > > +{ > > +} > > + > > long kvm_arch_vm_ioctl(struct file *filp, > > unsigned int ioctl, unsigned long arg) > > { > > What looks like you wants a __weak function. True. Thanks for the suggestion. I thought about it, but I recalled that tglx had __strong opinions on __weak functions.
On 04/06/21 02:39, Sergey Senozhatsky wrote: >>> >>> +void kvm_arch_pm_notifier(struct kvm *kvm) >>> +{ >>> +} >>> + >>> long kvm_arch_vm_ioctl(struct file *filp, >>> unsigned int ioctl, unsigned long arg) >>> { >> What looks like you wants a __weak function. > True. Thanks for the suggestion. > > I thought about it, but I recalled that tglx had __strong opinions > on __weak functions. > Alternatively, you can add a Kconfig symbol to virt/kvm/Kconfig and select it from arch/x86/kvm. Paolo
Sergey Senozhatsky <senozhatsky@chromium.org> writes: > Add KVM suspend/hibernate PM-notifier which lets architectures > to implement arch-specific VM suspend code. For instance, on x86 > this sets PVCLOCK_GUEST_STOPPED on all the VCPUs. > > Our case is that user puts the host system into sleep multiple > times a day (e.g. closes the laptop's lid) so we need a reliable > way to suspend VMs properly. > > Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org> > --- > arch/arm64/kvm/arm.c | 4 ++++ > arch/mips/kvm/mips.c | 4 ++++ > arch/powerpc/kvm/powerpc.c | 4 ++++ > arch/s390/kvm/kvm-s390.c | 4 ++++ > arch/x86/kvm/x86.c | 21 ++++++++++++++++++++ > include/linux/kvm_host.h | 8 ++++++++ > virt/kvm/kvm_main.c | 40 ++++++++++++++++++++++++++++++++++++++ > 7 files changed, 85 insertions(+) > > diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c > index 1126eae27400..547dbe44d039 100644 > --- a/arch/arm64/kvm/arm.c > +++ b/arch/arm64/kvm/arm.c > @@ -1311,6 +1311,10 @@ static int kvm_vm_ioctl_set_device_addr(struct kvm *kvm, > } > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c > index 4d4af97dcc88..d4408acd2be6 100644 > --- a/arch/mips/kvm/mips.c > +++ b/arch/mips/kvm/mips.c > @@ -980,6 +980,10 @@ void kvm_arch_flush_remote_tlbs_memslot(struct kvm *kvm, > kvm_flush_remote_tlbs(kvm); > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) > { > long r; > diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c > index a2a68a958fa0..96e8a7b6fcf0 100644 > --- a/arch/powerpc/kvm/powerpc.c > +++ b/arch/powerpc/kvm/powerpc.c > @@ -2334,6 +2334,10 @@ static int kvmppc_get_cpu_char(struct kvm_ppc_cpu_char *cp) > } > #endif > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c > index 1296fc10f80c..c5f86fc1e497 100644 > --- a/arch/s390/kvm/kvm-s390.c > +++ b/arch/s390/kvm/kvm-s390.c > @@ -2367,6 +2367,10 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) > return r; > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c > index bbc4e04e67ad..3f3d6497593f 100644 > --- a/arch/x86/kvm/x86.c > +++ b/arch/x86/kvm/x86.c > @@ -5613,6 +5613,27 @@ static int kvm_vm_ioctl_set_msr_filter(struct kvm *kvm, void __user *argp) > return 0; > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +#ifdef CONFIG_PM > + int c; > + > + mutex_lock(&kvm->lock); > + for (c = 0; c < kvm->created_vcpus; c++) { > + struct kvm_vcpu *vcpu = kvm->vcpus[c]; > + int r; > + > + if (!vcpu) > + continue; > + r = kvm_set_guest_paused(vcpu); > + if (!r) > + continue; > + pr_err("Failed to suspend VCPU-%d: %d\n", vcpu->vcpu_id, r); > + } > + mutex_unlock(&kvm->lock); > +#endif > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h > index 2f34487e21f2..86695320a6b7 100644 > --- a/include/linux/kvm_host.h > +++ b/include/linux/kvm_host.h > @@ -37,6 +37,8 @@ > #include <asm/kvm_host.h> > #include <linux/kvm_dirty_ring.h> > > +#include <linux/notifier.h> > + > #ifndef KVM_MAX_VCPU_ID > #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS > #endif > @@ -579,6 +581,10 @@ struct kvm { > pid_t userspace_pid; > unsigned int max_halt_poll_ns; > u32 dirty_ring_size; > + > +#ifdef CONFIG_PM > + struct notifier_block pm_notifier; > +#endif > }; > > #define kvm_err(fmt, ...) \ > @@ -992,6 +998,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu); > void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu); > void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu); > > +void kvm_arch_pm_notifier(struct kvm *kvm); > + > #ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS > void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu, struct dentry *debugfs_dentry); > #endif > diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c > index 6b4feb92dc79..86925ab7d162 100644 > --- a/virt/kvm/kvm_main.c > +++ b/virt/kvm/kvm_main.c > @@ -51,6 +51,7 @@ > #include <linux/io.h> > #include <linux/lockdep.h> > #include <linux/kthread.h> > +#include <linux/suspend.h> > > #include <asm/processor.h> > #include <asm/ioctl.h> > @@ -779,6 +780,43 @@ static int kvm_init_mmu_notifier(struct kvm *kvm) > > #endif /* CONFIG_MMU_NOTIFIER && KVM_ARCH_WANT_MMU_NOTIFIER */ > > +#ifdef CONFIG_PM > +static int kvm_pm_notifier_call(struct notifier_block *bl, > + unsigned long state, > + void *unused) > +{ > + struct kvm *kvm = container_of(bl, struct kvm, pm_notifier); > + > + switch (state) { > + case PM_HIBERNATION_PREPARE: > + case PM_SUSPEND_PREPARE: > + kvm_arch_pm_notifier(kvm); > + break; > + } > + return NOTIFY_DONE; > +} > + > +static void kvm_init_pm_notifier(struct kvm *kvm) > +{ > + kvm->pm_notifier.notifier_call = kvm_pm_notifier_call; > + kvm->pm_notifier.priority = INT_MAX; > + register_pm_notifier(&kvm->pm_notifier); > +} > + > +static void kvm_destroy_pm_notifier(struct kvm *kvm) > +{ > + unregister_pm_notifier(&kvm->pm_notifier); > +} > +#else > +static void kvm_init_pm_notifier(struct kvm *kvm) > +{ > +} > + > +static void kvm_destroy_pm_notifier(struct kvm *kvm) > +{ > +} > +#endif /* CONFIG_PM */ > + > static struct kvm_memslots *kvm_alloc_memslots(void) > { > int i; > @@ -962,6 +1000,7 @@ static struct kvm *kvm_create_vm(unsigned long type) > mutex_unlock(&kvm_lock); > > preempt_notifier_inc(); > + kvm_init_pm_notifier(kvm); > You've probably thought it through and I didn't but wouldn't it be easier to have one global pm_notifier call for KVM which would go through the list of VMs instead of registering/deregistering a pm_notifier call for every created/destroyed VM? > return kvm; > > @@ -1009,6 +1048,7 @@ static void kvm_destroy_vm(struct kvm *kvm) > int i; > struct mm_struct *mm = kvm->mm; > > + kvm_destroy_pm_notifier(kvm); > kvm_uevent_notify_change(KVM_EVENT_DESTROY_VM, kvm); > kvm_destroy_vm_debugfs(kvm); > kvm_arch_sync_events(kvm);
On 04/06/21 09:21, Vitaly Kuznetsov wrote: >> >> preempt_notifier_inc(); >> + kvm_init_pm_notifier(kvm); >> > You've probably thought it through and I didn't but wouldn't it be > easier to have one global pm_notifier call for KVM which would go > through the list of VMs instead of registering/deregistering a > pm_notifier call for every created/destroyed VM? That raises questions on the locking, i.e. if we can we take the kvm_lock safely from the notifier. Paolo
On Thu, 03 Jun 2021 17:43:15 +0100, Sergey Senozhatsky <senozhatsky@chromium.org> wrote: > > Add KVM suspend/hibernate PM-notifier which lets architectures > to implement arch-specific VM suspend code. For instance, on x86 > this sets PVCLOCK_GUEST_STOPPED on all the VCPUs. > > Our case is that user puts the host system into sleep multiple > times a day (e.g. closes the laptop's lid) so we need a reliable > way to suspend VMs properly. > > Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org> > --- > arch/arm64/kvm/arm.c | 4 ++++ > arch/mips/kvm/mips.c | 4 ++++ > arch/powerpc/kvm/powerpc.c | 4 ++++ > arch/s390/kvm/kvm-s390.c | 4 ++++ > arch/x86/kvm/x86.c | 21 ++++++++++++++++++++ > include/linux/kvm_host.h | 8 ++++++++ > virt/kvm/kvm_main.c | 40 ++++++++++++++++++++++++++++++++++++++ > 7 files changed, 85 insertions(+) > > diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c > index 1126eae27400..547dbe44d039 100644 > --- a/arch/arm64/kvm/arm.c > +++ b/arch/arm64/kvm/arm.c > @@ -1311,6 +1311,10 @@ static int kvm_vm_ioctl_set_device_addr(struct kvm *kvm, > } > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c > index 4d4af97dcc88..d4408acd2be6 100644 > --- a/arch/mips/kvm/mips.c > +++ b/arch/mips/kvm/mips.c > @@ -980,6 +980,10 @@ void kvm_arch_flush_remote_tlbs_memslot(struct kvm *kvm, > kvm_flush_remote_tlbs(kvm); > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) > { > long r; > diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c > index a2a68a958fa0..96e8a7b6fcf0 100644 > --- a/arch/powerpc/kvm/powerpc.c > +++ b/arch/powerpc/kvm/powerpc.c > @@ -2334,6 +2334,10 @@ static int kvmppc_get_cpu_char(struct kvm_ppc_cpu_char *cp) > } > #endif > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c > index 1296fc10f80c..c5f86fc1e497 100644 > --- a/arch/s390/kvm/kvm-s390.c > +++ b/arch/s390/kvm/kvm-s390.c > @@ -2367,6 +2367,10 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) > return r; > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c > index bbc4e04e67ad..3f3d6497593f 100644 > --- a/arch/x86/kvm/x86.c > +++ b/arch/x86/kvm/x86.c > @@ -5613,6 +5613,27 @@ static int kvm_vm_ioctl_set_msr_filter(struct kvm *kvm, void __user *argp) > return 0; > } > > +void kvm_arch_pm_notifier(struct kvm *kvm) > +{ > +#ifdef CONFIG_PM > + int c; > + > + mutex_lock(&kvm->lock); > + for (c = 0; c < kvm->created_vcpus; c++) { > + struct kvm_vcpu *vcpu = kvm->vcpus[c]; > + int r; > + > + if (!vcpu) > + continue; Wouldn't kvm_for_each_vcpu() avoid this kind of checks? > + r = kvm_set_guest_paused(vcpu); > + if (!r) > + continue; > + pr_err("Failed to suspend VCPU-%d: %d\n", vcpu->vcpu_id, r); > + } > + mutex_unlock(&kvm->lock); > +#endif > +} > + > long kvm_arch_vm_ioctl(struct file *filp, > unsigned int ioctl, unsigned long arg) > { > diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h > index 2f34487e21f2..86695320a6b7 100644 > --- a/include/linux/kvm_host.h > +++ b/include/linux/kvm_host.h > @@ -37,6 +37,8 @@ > #include <asm/kvm_host.h> > #include <linux/kvm_dirty_ring.h> > > +#include <linux/notifier.h> > + > #ifndef KVM_MAX_VCPU_ID > #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS > #endif > @@ -579,6 +581,10 @@ struct kvm { > pid_t userspace_pid; > unsigned int max_halt_poll_ns; > u32 dirty_ring_size; > + > +#ifdef CONFIG_PM > + struct notifier_block pm_notifier; > +#endif I'd certainly like to be able to opt out from this on architectures that do not implement anything useful in the PM callbacks. Please consider making this an independent config option that individual archs can buy into. > }; > > #define kvm_err(fmt, ...) \ > @@ -992,6 +998,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu); > void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu); > void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu); > > +void kvm_arch_pm_notifier(struct kvm *kvm); > + > #ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS > void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu, struct dentry *debugfs_dentry); > #endif > diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c > index 6b4feb92dc79..86925ab7d162 100644 > --- a/virt/kvm/kvm_main.c > +++ b/virt/kvm/kvm_main.c > @@ -51,6 +51,7 @@ > #include <linux/io.h> > #include <linux/lockdep.h> > #include <linux/kthread.h> > +#include <linux/suspend.h> > > #include <asm/processor.h> > #include <asm/ioctl.h> > @@ -779,6 +780,43 @@ static int kvm_init_mmu_notifier(struct kvm *kvm) > > #endif /* CONFIG_MMU_NOTIFIER && KVM_ARCH_WANT_MMU_NOTIFIER */ > > +#ifdef CONFIG_PM > +static int kvm_pm_notifier_call(struct notifier_block *bl, > + unsigned long state, > + void *unused) > +{ > + struct kvm *kvm = container_of(bl, struct kvm, pm_notifier); > + > + switch (state) { > + case PM_HIBERNATION_PREPARE: > + case PM_SUSPEND_PREPARE: > + kvm_arch_pm_notifier(kvm); How about passing the state to the notifier callback? I'd expect it to be useful to do something on resume too. > + break; > + } > + return NOTIFY_DONE; > +} > + > +static void kvm_init_pm_notifier(struct kvm *kvm) > +{ > + kvm->pm_notifier.notifier_call = kvm_pm_notifier_call; > + kvm->pm_notifier.priority = INT_MAX; How is this priority determined? > + register_pm_notifier(&kvm->pm_notifier); > +} > + > +static void kvm_destroy_pm_notifier(struct kvm *kvm) > +{ > + unregister_pm_notifier(&kvm->pm_notifier); > +} > +#else > +static void kvm_init_pm_notifier(struct kvm *kvm) > +{ > +} > + > +static void kvm_destroy_pm_notifier(struct kvm *kvm) > +{ > +} > +#endif /* CONFIG_PM */ > + > static struct kvm_memslots *kvm_alloc_memslots(void) > { > int i; > @@ -962,6 +1000,7 @@ static struct kvm *kvm_create_vm(unsigned long type) > mutex_unlock(&kvm_lock); > > preempt_notifier_inc(); > + kvm_init_pm_notifier(kvm); > > return kvm; > > @@ -1009,6 +1048,7 @@ static void kvm_destroy_vm(struct kvm *kvm) > int i; > struct mm_struct *mm = kvm->mm; > > + kvm_destroy_pm_notifier(kvm); > kvm_uevent_notify_change(KVM_EVENT_DESTROY_VM, kvm); > kvm_destroy_vm_debugfs(kvm); > kvm_arch_sync_events(kvm); Thanks, M.
On (21/06/04 09:46), Marc Zyngier wrote: [..] > > +void kvm_arch_pm_notifier(struct kvm *kvm) > > +{ > > +#ifdef CONFIG_PM > > + int c; > > + > > + mutex_lock(&kvm->lock); > > + for (c = 0; c < kvm->created_vcpus; c++) { > > + struct kvm_vcpu *vcpu = kvm->vcpus[c]; > > + int r; > > + > > + if (!vcpu) > > + continue; > > Wouldn't kvm_for_each_vcpu() avoid this kind of checks? Right, that's what I do in v2, which I haven't posted yet. [..] > > +#include <linux/notifier.h> > > + > > #ifndef KVM_MAX_VCPU_ID > > #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS > > #endif > > @@ -579,6 +581,10 @@ struct kvm { > > pid_t userspace_pid; > > unsigned int max_halt_poll_ns; > > u32 dirty_ring_size; > > + > > +#ifdef CONFIG_PM > > + struct notifier_block pm_notifier; > > +#endif > > I'd certainly like to be able to opt out from this on architectures > that do not implement anything useful in the PM callbacks. Well on the other hand PM-callbacks are harmless on those archs, they won't overload the __weak function. > Please consider making this an independent config option that individual > archs can buy into. Sure, I can take a look into this, but how is this better than __weak function? (that's a real question) [..] > > +#ifdef CONFIG_PM > > +static int kvm_pm_notifier_call(struct notifier_block *bl, > > + unsigned long state, > > + void *unused) > > +{ > > + struct kvm *kvm = container_of(bl, struct kvm, pm_notifier); > > + > > + switch (state) { > > + case PM_HIBERNATION_PREPARE: > > + case PM_SUSPEND_PREPARE: > > + kvm_arch_pm_notifier(kvm); > > How about passing the state to the notifier callback? I'd expect it to > be useful to do something on resume too. For different states we can have different kvm_arch functions instead. kvm_arch_pm_notifier() can be renamed to kvm_arch_suspend_notifier(), so that we don't need to have `switch (state)` in every arch-code. Then for resume/post resume states we can have kvm_arch_resume_notifier() arch functions. > > + break; > > + } > > + return NOTIFY_DONE; > > +} > > + > > +static void kvm_init_pm_notifier(struct kvm *kvm) > > +{ > > + kvm->pm_notifier.notifier_call = kvm_pm_notifier_call; > > + kvm->pm_notifier.priority = INT_MAX; > > How is this priority determined? Nothing magical here. I want this to be executed first, before we suspend ftrace, RCU and the like. Besides KVM is usually the last one to register its PM callbacks, so there can be something on the notifier list that returns NOTIFY_STOP_MASK in front of KVM PM-notifier list entry.
On (21/06/04 09:24), Paolo Bonzini wrote: > On 04/06/21 09:21, Vitaly Kuznetsov wrote: > > > preempt_notifier_inc(); > > > + kvm_init_pm_notifier(kvm); > > You've probably thought it through and I didn't but wouldn't it be > > easier to have one global pm_notifier call for KVM which would go > > through the list of VMs instead of registering/deregistering a > > pm_notifier call for every created/destroyed VM? > > That raises questions on the locking, i.e. if we can we take the kvm_lock > safely from the notifier. Right, I wanted to take the VM lock, rather than subsystem lock (kvm_lock).
On Fri, 04 Jun 2021 10:20:28 +0100, Sergey Senozhatsky <senozhatsky@chromium.org> wrote: > > On (21/06/04 09:46), Marc Zyngier wrote: > [..] > > > +void kvm_arch_pm_notifier(struct kvm *kvm) > > > +{ > > > +#ifdef CONFIG_PM > > > + int c; > > > + > > > + mutex_lock(&kvm->lock); > > > + for (c = 0; c < kvm->created_vcpus; c++) { > > > + struct kvm_vcpu *vcpu = kvm->vcpus[c]; > > > + int r; > > > + > > > + if (!vcpu) > > > + continue; > > > > Wouldn't kvm_for_each_vcpu() avoid this kind of checks? > > Right, that's what I do in v2, which I haven't posted yet. > > [..] > > > +#include <linux/notifier.h> > > > + > > > #ifndef KVM_MAX_VCPU_ID > > > #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS > > > #endif > > > @@ -579,6 +581,10 @@ struct kvm { > > > pid_t userspace_pid; > > > unsigned int max_halt_poll_ns; > > > u32 dirty_ring_size; > > > + > > > +#ifdef CONFIG_PM > > > + struct notifier_block pm_notifier; > > > +#endif > > > > I'd certainly like to be able to opt out from this on architectures > > that do not implement anything useful in the PM callbacks. > > Well on the other hand PM-callbacks are harmless on those archs, they > won't overload the __weak function. I don't care much for the callbacks. But struct kvm is bloated enough, and I'd be happy not to have this structure embedded in it if I can avoid it. > > > Please consider making this an independent config option that individual > > archs can buy into. > > Sure, I can take a look into this, but how is this better than __weak > function? (that's a real question) Weak functions are OK AFAIC. More crud in struct kvm is what I'm not OK with. > > [..] > > > +#ifdef CONFIG_PM > > > +static int kvm_pm_notifier_call(struct notifier_block *bl, > > > + unsigned long state, > > > + void *unused) > > > +{ > > > + struct kvm *kvm = container_of(bl, struct kvm, pm_notifier); > > > + > > > + switch (state) { > > > + case PM_HIBERNATION_PREPARE: > > > + case PM_SUSPEND_PREPARE: > > > + kvm_arch_pm_notifier(kvm); > > > > How about passing the state to the notifier callback? I'd expect it to > > be useful to do something on resume too. > > For different states we can have different kvm_arch functions instead. > kvm_arch_pm_notifier() can be renamed to kvm_arch_suspend_notifier(), > so that we don't need to have `switch (state)` in every arch-code. Then > for resume/post resume states we can have kvm_arch_resume_notifier() > arch functions. I'd rather we keep an arch API that is similar to the one the rest of the kernel has, instead of a flurry of small helpers that need to grow each time someone adds a new PM state. A switch() in the arch-specific implementation is absolutely fine. > > > > + break; > > > + } > > > + return NOTIFY_DONE; > > > +} > > > + > > > +static void kvm_init_pm_notifier(struct kvm *kvm) > > > +{ > > > + kvm->pm_notifier.notifier_call = kvm_pm_notifier_call; > > > + kvm->pm_notifier.priority = INT_MAX; > > > > How is this priority determined? > > Nothing magical here. I want this to be executed first, before we suspend > ftrace, RCU and the like. Besides KVM is usually the last one to register > its PM callbacks, so there can be something on the notifier list that > returns NOTIFY_STOP_MASK in front of KVM PM-notifier list entry. Which begs the question: should arch-specific code be able to veto suspend and return an error itself? Always returning NOTIFY_DONE seems highly optimistic. M.
On (21/06/04 11:03), Marc Zyngier wrote: [..] > > Well on the other hand PM-callbacks are harmless on those archs, they > > won't overload the __weak function. > > I don't care much for the callbacks. But struct kvm is bloated enough, > and I'd be happy not to have this structure embedded in it if I can > avoid it. Got it. > > > How about passing the state to the notifier callback? I'd expect it to > > > be useful to do something on resume too. > > > > For different states we can have different kvm_arch functions instead. > > kvm_arch_pm_notifier() can be renamed to kvm_arch_suspend_notifier(), > > so that we don't need to have `switch (state)` in every arch-code. Then > > for resume/post resume states we can have kvm_arch_resume_notifier() > > arch functions. > > I'd rather we keep an arch API that is similar to the one the rest of > the kernel has, instead of a flurry of small helpers that need to grow > each time someone adds a new PM state. A switch() in the arch-specific > implementation is absolutely fine. OK.
diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c index 1126eae27400..547dbe44d039 100644 --- a/arch/arm64/kvm/arm.c +++ b/arch/arm64/kvm/arm.c @@ -1311,6 +1311,10 @@ static int kvm_vm_ioctl_set_device_addr(struct kvm *kvm, } } +void kvm_arch_pm_notifier(struct kvm *kvm) +{ +} + long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { diff --git a/arch/mips/kvm/mips.c b/arch/mips/kvm/mips.c index 4d4af97dcc88..d4408acd2be6 100644 --- a/arch/mips/kvm/mips.c +++ b/arch/mips/kvm/mips.c @@ -980,6 +980,10 @@ void kvm_arch_flush_remote_tlbs_memslot(struct kvm *kvm, kvm_flush_remote_tlbs(kvm); } +void kvm_arch_pm_notifier(struct kvm *kvm) +{ +} + long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { long r; diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c index a2a68a958fa0..96e8a7b6fcf0 100644 --- a/arch/powerpc/kvm/powerpc.c +++ b/arch/powerpc/kvm/powerpc.c @@ -2334,6 +2334,10 @@ static int kvmppc_get_cpu_char(struct kvm_ppc_cpu_char *cp) } #endif +void kvm_arch_pm_notifier(struct kvm *kvm) +{ +} + long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c index 1296fc10f80c..c5f86fc1e497 100644 --- a/arch/s390/kvm/kvm-s390.c +++ b/arch/s390/kvm/kvm-s390.c @@ -2367,6 +2367,10 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd) return r; } +void kvm_arch_pm_notifier(struct kvm *kvm) +{ +} + long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index bbc4e04e67ad..3f3d6497593f 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -5613,6 +5613,27 @@ static int kvm_vm_ioctl_set_msr_filter(struct kvm *kvm, void __user *argp) return 0; } +void kvm_arch_pm_notifier(struct kvm *kvm) +{ +#ifdef CONFIG_PM + int c; + + mutex_lock(&kvm->lock); + for (c = 0; c < kvm->created_vcpus; c++) { + struct kvm_vcpu *vcpu = kvm->vcpus[c]; + int r; + + if (!vcpu) + continue; + r = kvm_set_guest_paused(vcpu); + if (!r) + continue; + pr_err("Failed to suspend VCPU-%d: %d\n", vcpu->vcpu_id, r); + } + mutex_unlock(&kvm->lock); +#endif +} + long kvm_arch_vm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) { diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 2f34487e21f2..86695320a6b7 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -37,6 +37,8 @@ #include <asm/kvm_host.h> #include <linux/kvm_dirty_ring.h> +#include <linux/notifier.h> + #ifndef KVM_MAX_VCPU_ID #define KVM_MAX_VCPU_ID KVM_MAX_VCPUS #endif @@ -579,6 +581,10 @@ struct kvm { pid_t userspace_pid; unsigned int max_halt_poll_ns; u32 dirty_ring_size; + +#ifdef CONFIG_PM + struct notifier_block pm_notifier; +#endif }; #define kvm_err(fmt, ...) \ @@ -992,6 +998,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu); void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu); void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu); +void kvm_arch_pm_notifier(struct kvm *kvm); + #ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS void kvm_arch_create_vcpu_debugfs(struct kvm_vcpu *vcpu, struct dentry *debugfs_dentry); #endif diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index 6b4feb92dc79..86925ab7d162 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -51,6 +51,7 @@ #include <linux/io.h> #include <linux/lockdep.h> #include <linux/kthread.h> +#include <linux/suspend.h> #include <asm/processor.h> #include <asm/ioctl.h> @@ -779,6 +780,43 @@ static int kvm_init_mmu_notifier(struct kvm *kvm) #endif /* CONFIG_MMU_NOTIFIER && KVM_ARCH_WANT_MMU_NOTIFIER */ +#ifdef CONFIG_PM +static int kvm_pm_notifier_call(struct notifier_block *bl, + unsigned long state, + void *unused) +{ + struct kvm *kvm = container_of(bl, struct kvm, pm_notifier); + + switch (state) { + case PM_HIBERNATION_PREPARE: + case PM_SUSPEND_PREPARE: + kvm_arch_pm_notifier(kvm); + break; + } + return NOTIFY_DONE; +} + +static void kvm_init_pm_notifier(struct kvm *kvm) +{ + kvm->pm_notifier.notifier_call = kvm_pm_notifier_call; + kvm->pm_notifier.priority = INT_MAX; + register_pm_notifier(&kvm->pm_notifier); +} + +static void kvm_destroy_pm_notifier(struct kvm *kvm) +{ + unregister_pm_notifier(&kvm->pm_notifier); +} +#else +static void kvm_init_pm_notifier(struct kvm *kvm) +{ +} + +static void kvm_destroy_pm_notifier(struct kvm *kvm) +{ +} +#endif /* CONFIG_PM */ + static struct kvm_memslots *kvm_alloc_memslots(void) { int i; @@ -962,6 +1000,7 @@ static struct kvm *kvm_create_vm(unsigned long type) mutex_unlock(&kvm_lock); preempt_notifier_inc(); + kvm_init_pm_notifier(kvm); return kvm; @@ -1009,6 +1048,7 @@ static void kvm_destroy_vm(struct kvm *kvm) int i; struct mm_struct *mm = kvm->mm; + kvm_destroy_pm_notifier(kvm); kvm_uevent_notify_change(KVM_EVENT_DESTROY_VM, kvm); kvm_destroy_vm_debugfs(kvm); kvm_arch_sync_events(kvm);
Add KVM suspend/hibernate PM-notifier which lets architectures to implement arch-specific VM suspend code. For instance, on x86 this sets PVCLOCK_GUEST_STOPPED on all the VCPUs. Our case is that user puts the host system into sleep multiple times a day (e.g. closes the laptop's lid) so we need a reliable way to suspend VMs properly. Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org> --- arch/arm64/kvm/arm.c | 4 ++++ arch/mips/kvm/mips.c | 4 ++++ arch/powerpc/kvm/powerpc.c | 4 ++++ arch/s390/kvm/kvm-s390.c | 4 ++++ arch/x86/kvm/x86.c | 21 ++++++++++++++++++++ include/linux/kvm_host.h | 8 ++++++++ virt/kvm/kvm_main.c | 40 ++++++++++++++++++++++++++++++++++++++ 7 files changed, 85 insertions(+)