KVM: s390: pv: implement lazy destroy for reboot
Subsystems (5)
Claudio Imbrenda
maintainerv8 cover KVM: s390: pv: implement lazy destroy for reboot
Previously, when a protected VM was rebooted or when it was shut down, its memory was made unprotected, and then the protected VM itself was destroyed. Looping over the whole address space can take some time, considering the overhead of the various Ultravisor Calls (UVCs). This means that a reboot or a shutdown would take a potentially long amount of time, depending on the amount of used memory.
This patchseries implements a deferred destroy mechanism for protected guests. When a protected guest is destroyed, its memory can be cleared in background, allowing the guest to restart or terminate significantly faster than before.
There are 2 possibilities when a protected VM is torn down:
* it still has an address space associated (reboot case)
* it does not have an address space anymore (shutdown case)
For the reboot case, two new commands are available for the KVM_S390_PV_COMMAND:
KVM_PV_ASYNC_DISABLE_PREPARE: prepares the current protected VM for asynchronous teardown. The current VM will then continue immediately as non-protected. If a protected VM had already been set aside without starting the teardown process, this call will fail. In this case the userspace process should issue a normal KVM_PV_DISABLE
KVM_PV_ASYNC_DISABLE: tears down the protected VM previously set aside for asychronous teardown. This PV command should ideally be issued by userspace from a separate thread. If a fatal signal is received (or the process terminates naturally), the command will terminate immediately without completing.
The idea is that userspace should first issue the KVM_PV_ASYNC_DISABLE_PREPARE command, and in case of success, create a new thread and issue KVM_PV_ASYNC_DISABLE from there. This also allows for proper accounting of the CPU time needed for the asynchronous teardown.
This means that the same address space can have memory belonging to more than one protected guest, although only one will be running, the others will in fact not even have any CPUs.
The shutdown case should be dealt with in userspace (e.g. using clone(CLONE_VM)).
A module parameter is also provided to disable the new functionality, which is otherwise enabled by default. This should not be an issue since the new functionality is opt-in anyway. This is mainly thought to aid debugging.
v7->v8
* switched patches 8 and 9
* improved comments, documentation and patch descriptions
* remove mm notifier when the struct kvm is torn down
* removed useless locks in the mm notifier
* use _ASCE_ORIGIN instead of PAGE_MASK for ASCEs
* cleanup of some compiler warnings
* remove some harmless but useless duplicate code
* the last parameter of __s390_uv_destroy_range is now bool
* rename the KVM capability to KVM_CAP_S390_PROTECTED_ASYNC_DISABLE
v6->v7
* moved INIT_LIST_HEAD inside spinlock in patch 1
* improved commit messages in patch 2
* added missing locks in patch 3
* added and expanded some comments in patch 11
* rebased
v5->v6
* completely reworked the series
* removed kernel thread for asynchronous teardown
* added new commands to KVM_S390_PV_COMMAND ioctl
v4->v5
* fixed and improved some patch descriptions
* added some comments to better explain what's going on
* use vma_lookup instead of find_vma
* rename is_protected to protected_count since now it's used as a counter
v3->v4
* added patch 2
* split patch 3
* removed the shutdown part -- will be a separate patchseries
* moved the patch introducing the module parameter
v2->v3
* added definitions for CC return codes for the UVC instruction
* improved make_secure_pte:
- renamed rc to cc
- added comments to explain why returning -EAGAIN is ok
* fixed kvm_s390_pv_replace_asce and kvm_s390_pv_remove_old_asce:
- renamed
- added locking
- moved to gmap.c
* do proper error management in do_secure_storage_access instead of trying again hoping to get a different exception
* fix outdated patch descriptions
v1->v2
* rebased on a more recent kernel
* improved/expanded some patch descriptions
* improves/expanded some comments
* added patch 1, which prevents stall notification when the system is under heavy load.
* rename some members of struct deferred_priv to improve readability
* avoid an use-after-free bug of the struct mm in case of shutdown
* add missing return when lazy destroy is disabled
* add support for OOM notifier
Claudio Imbrenda (17):
KVM: s390: pv: leak the topmost page table when destroy fails
KVM: s390: pv: handle secure storage violations for protected guests
KVM: s390: pv: handle secure storage exceptions for normal guests
KVM: s390: pv: refactor s390_reset_acc
KVM: s390: pv: usage counter instead of flag
KVM: s390: pv: add export before import
KVM: s390: pv: module parameter to fence lazy destroy
KVM: s390: pv: clear the state without memset
KVM: s390: pv: Add kvm_s390_cpus_from_pv to kvm-s390.h and add
documentation
KVM: s390: pv: add mmu_notifier
s390/mm: KVM: pv: when tearing down, try to destroy protected pages
KVM: s390: pv: refactoring of kvm_s390_pv_deinit_vm
KVM: s390: pv: cleanup leftover protected VMs if needed
KVM: s390: pv: asynchronous destroy for reboot
KVM: s390: pv: api documentation for asynchronous destroy
KVM: s390: pv: add KVM_CAP_S390_PROTECTED_ASYNC_DISABLE
KVM: s390: pv: avoid export before import if possible
Documentation/virt/kvm/api.rst | 25 ++- arch/s390/include/asm/gmap.h | 39 +++- arch/s390/include/asm/kvm_host.h | 4 + arch/s390/include/asm/mmu.h | 2 +- arch/s390/include/asm/mmu_context.h | 2 +- arch/s390/include/asm/pgtable.h | 20 ++- arch/s390/include/asm/uv.h | 1 + arch/s390/kernel/uv.c | 64 +++++++ arch/s390/kvm/kvm-s390.c | 64 ++++++- arch/s390/kvm/kvm-s390.h | 3 + arch/s390/kvm/pv.c | 264 ++++++++++++++++++++++++++-- arch/s390/mm/fault.c | 23 ++- arch/s390/mm/gmap.c | 158 ++++++++++++++--- include/uapi/linux/kvm.h | 3 + 14 files changed, 623 insertions(+), 49 deletions(-)
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 1/17 KVM: s390: pv: leak the topmost page table when destroy fails
Each secure guest must have a unique ASCE (address space control element); we must avoid that new guests use the same page for their ASCE, to avoid errors.
Since the ASCE mostly consists of the address of the topmost page table (plus some flags), we must not return that memory to the pool unless the ASCE is no longer in use.
Only a successful Destroy Secure Configuration UVC will make the ASCE reusable again.
If the Destroy Configuration UVC fails, the ASCE cannot be reused for a secure guest (either for the ASCE or for other memory areas). To avoid a collision, it must not be used again. This is a permanent error and the page becomes in practice unusable, so we set it aside and leak it. On failure we already leak other memory that belongs to the ultravisor (i.e. the variable and base storage for a guest) and not leaking the topmost page table was an oversight.
This error (and thus the leakage) should not happen unless the hardware is broken or KVM has some unknown serious bug.
--- arch/s390/include/asm/gmap.h | 2 + arch/s390/kvm/pv.c | 9 +++-- arch/s390/mm/gmap.c | 71 ++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 3 deletions(-)
arch/s390/include/asm/gmap.h +2 -0
@@ -148,4 +148,6 @@ void gmap_sync_dirty_log_pmd(struct gmap *gmap, unsigned long dirty_bitmap[4], unsigned long gaddr, unsigned long vmaddr);int gmap_mark_unmergeable (void );void s390_reset_acc (struct mm_struct *mm); +void s390_remove_old_asce (struct gmap *gmap); +int s390_replace_asce (struct gmap *gmap);#endif /* _ASM_S390_GMAP_H */
arch/s390/kvm/pv.c +6 -3
@@ -166,10 +166,13 @@ int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc)atomic_set (&kvm->mm->context.is_protected,0 );KVM_UV_EVENT (kvm,3 ,"PROTVIRT DESTROY VM: rc %x rrc %x" , *rc, *rrc);WARN_ONCE (cc,"protvirt destroy vm failed rc %x rrc %x" , *rc, *rrc); -/* Inteded memory leak on "impossible" error */ -if (!cc) +/* Intended memory leak on "impossible" error */ +if (!cc) {kvm_s390_pv_dealloc_vm (kvm); -return cc ? -EIO :0 ; +return 0 ; + } +s390_replace_asce (kvm->arch.gmap); +return -EIO ; }int kvm_s390_pv_init_vm (struct kvm *kvm,u16 *rc,u16 *rrc)
arch/s390/mm/gmap.c +71 -0
74 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH v8 01/17] KVM: s390: pv: leak the topmost page table when destroy fails
Quoted 30 lines · Claudio Imbrenda
Each secure guest must have a unique ASCE (address space control element); we must avoid that new guests use the same page for their ASCE, to avoid errors.
Since the ASCE mostly consists of the address of the topmost page table (plus some flags), we must not return that memory to the pool unless the ASCE is no longer in use.
Only a successful Destroy Secure Configuration UVC will make the ASCE reusable again.
If the Destroy Configuration UVC fails, the ASCE cannot be reused for a secure guest (either for the ASCE or for other memory areas). To avoid a collision, it must not be used again. This is a permanent error and the page becomes in practice unusable, so we set it aside and leak it. On failure we already leak other memory that belongs to the ultravisor (i.e. the variable and base storage for a guest) and not leaking the topmost page table was an oversight.
This error (and thus the leakage) should not happen unless the hardware is broken or KVM has some unknown serious bug.
Signed-off-by Claudio Imbrenda <[email protected]>Fixes 29b40f105ec8d55 ("KVM: s390: protvirt: Add initial vm and cpu lifecycle handling")--- arch/s390/include/asm/gmap.h | 2 + arch/s390/kvm/pv.c | 9 +++-- arch/s390/mm/gmap.c | 71 ++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 3 deletions(-)
[...]
Quoted 14 lines
arch/s390/mm/gmap.c +14
-0+/** +* s390_replace_asce - Try to replace the current ASCE of a gmap with +* another equivalent one. +* @gmap the gmap +* +* If the allocation of the new top level page table fails, the ASCE is not +* replaced. +* In any case, the old ASCE is always removed from the list. Therefore the +* caller has to make sure to save a pointer to it beforehands, unless an +* intentional leak is intended. +*/ +int s390_replace_asce (struct gmap *gmap) +{ +unsigned long asce;
arch/s390/mm/gmap.c void s390_reset_acc(struct mm_struct *mm) · line 2768
Quoted 10 lines
arch/s390/mm/gmap.c +10
-0+struct page *page; +void *table; + +s390_remove_old_asce (gmap); + + page =alloc_pages (GFP_KERNEL_ACCOUNT ,CRST_ALLOC_ORDER ); +if (!page) +return -ENOMEM ; + table =page_to_virt (page); +memcpy (table, gmap->table,1UL << (CRST_ALLOC_ORDER +PAGE_SHIFT ));
Is concurrent modification of *gmap->table possible during the copy?
Quoted 19 lines
arch/s390/mm/gmap.c +19
-0+ +/* +* The caller has to deal with the old ASCE, but here we make sure +* the new one is properly added to the list of page tables, so that +* it will be freed when the VM is torn down. +*/ +spin_lock (&gmap->guest_table_lock); +list_add (&page->lru, &gmap->crst_list); +spin_unlock (&gmap->guest_table_lock); + +/* Set new table origin while preserving existing ASCE control bits */ + asce = (gmap->asce & _ASCE_ORIGIN) |__pa (table); +WRITE_ONCE (gmap->asce, asce); +WRITE_ONCE (gmap->mm->context.gmap_asce, asce); +WRITE_ONCE (gmap->table, table); + +return 0 ; +} +EXPORT_SYMBOL_GPL (s390_replace_asce);
Claudio Imbrenda
maintainerRe: [PATCH v8 01/17] KVM: s390: pv: leak the topmost page table when destroy fails
Quoted 51 lines · On Thu, 3 Mar 2022 15:40:42 +0100 Janis Schoetterl-Glausch…
Quoted 30 lines · Claudio Imbrenda
Each secure guest must have a unique ASCE (address space control element); we must avoid that new guests use the same page for their ASCE, to avoid errors.
Since the ASCE mostly consists of the address of the topmost page table (plus some flags), we must not return that memory to the pool unless the ASCE is no longer in use.
Only a successful Destroy Secure Configuration UVC will make the ASCE reusable again.
If the Destroy Configuration UVC fails, the ASCE cannot be reused for a secure guest (either for the ASCE or for other memory areas). To avoid a collision, it must not be used again. This is a permanent error and the page becomes in practice unusable, so we set it aside and leak it. On failure we already leak other memory that belongs to the ultravisor (i.e. the variable and base storage for a guest) and not leaking the topmost page table was an oversight.
This error (and thus the leakage) should not happen unless the hardware is broken or KVM has some unknown serious bug.
Signed-off-by Claudio Imbrenda <[email protected]>Fixes 29b40f105ec8d55 ("KVM: s390: protvirt: Add initial vm and cpu lifecycle handling")--- arch/s390/include/asm/gmap.h | 2 + arch/s390/kvm/pv.c | 9 +++-- arch/s390/mm/gmap.c | 71 ++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 3 deletions(-)[...]
Quoted 18 lines
arch/s390/mm/gmap.c +18
-0+/** +* s390_replace_asce - Try to replace the current ASCE of a gmap with +* another equivalent one. +* @gmap the gmap +* +* If the allocation of the new top level page table fails, the ASCE is not +* replaced. +* In any case, the old ASCE is always removed from the list. Therefore the +* caller has to make sure to save a pointer to it beforehands, unless an +* intentional leak is intended. +*/ +int s390_replace_asce (struct gmap *gmap) +{ +unsigned long asce; +struct page *page; +void *table; + +s390_remove_old_asce (gmap);
Quoted 8 lines
arch/s390/mm/gmap.c void s390_reset_acc(struct mm_struct *mm) · line 2768
Quoted 6 lines
arch/s390/mm/gmap.c +6
-0+ + page =alloc_pages (GFP_KERNEL_ACCOUNT ,CRST_ALLOC_ORDER ); +if (!page) +return -ENOMEM ; + table =page_to_virt (page); +memcpy (table, gmap->table,1UL << (CRST_ALLOC_ORDER +PAGE_SHIFT ));Is concurrent modification of
*gmap->tablepossible during the copy?
that would only be possible if the guest touches memory in such way that the table needs to be changed.
this function is only called when the guest is not running (e.g. during reboot), so nobody should touch the table
Quoted 21 lines
Quoted 20 lines
arch/s390/mm/gmap.c +19
-0+ +/* +* The caller has to deal with the old ASCE, but here we make sure +* the new one is properly added to the list of page tables, so that +* it will be freed when the VM is torn down. +*/ +spin_lock (&gmap->guest_table_lock); +list_add (&page->lru, &gmap->crst_list); +spin_unlock (&gmap->guest_table_lock); + +/* Set new table origin while preserving existing ASCE control bits */ + asce = (gmap->asce & _ASCE_ORIGIN) |__pa (table); +WRITE_ONCE (gmap->asce, asce); +WRITE_ONCE (gmap->mm->context.gmap_asce, asce); +WRITE_ONCE (gmap->table, table); + +return 0 ; +} +EXPORT_SYMBOL_GPL (s390_replace_asce);
Re: [PATCH v8 01/17] KVM: s390: pv: leak the topmost page table when destroy fails
Quoted 63 lines · Claudio Imbrenda
Quoted 51 lines · On Thu, 3 Mar 2022 15:40:42 +0100 Janis Schoetterl-Glausch…
Quoted 30 lines · Claudio Imbrenda
Each secure guest must have a unique ASCE (address space control element); we must avoid that new guests use the same page for their ASCE, to avoid errors.
Since the ASCE mostly consists of the address of the topmost page table (plus some flags), we must not return that memory to the pool unless the ASCE is no longer in use.
Only a successful Destroy Secure Configuration UVC will make the ASCE reusable again.
If the Destroy Configuration UVC fails, the ASCE cannot be reused for a secure guest (either for the ASCE or for other memory areas). To avoid a collision, it must not be used again. This is a permanent error and the page becomes in practice unusable, so we set it aside and leak it. On failure we already leak other memory that belongs to the ultravisor (i.e. the variable and base storage for a guest) and not leaking the topmost page table was an oversight.
This error (and thus the leakage) should not happen unless the hardware is broken or KVM has some unknown serious bug.
Signed-off-by Claudio Imbrenda <[email protected]>Fixes 29b40f105ec8d55 ("KVM: s390: protvirt: Add initial vm and cpu lifecycle handling")--- arch/s390/include/asm/gmap.h | 2 + arch/s390/kvm/pv.c | 9 +++-- arch/s390/mm/gmap.c | 71 ++++++++++++++++++++++++++++++++++++ 3 files changed, 79 insertions(+), 3 deletions(-)[...]
Quoted 18 lines
arch/s390/mm/gmap.c +18
-0+/** +* s390_replace_asce - Try to replace the current ASCE of a gmap with +* another equivalent one. +* @gmap the gmap +* +* If the allocation of the new top level page table fails, the ASCE is not +* replaced. +* In any case, the old ASCE is always removed from the list. Therefore the +* caller has to make sure to save a pointer to it beforehands, unless an +* intentional leak is intended. +*/ +int s390_replace_asce (struct gmap *gmap) +{ +unsigned long asce; +struct page *page; +void *table; + +s390_remove_old_asce (gmap);Quoted 8 lines
arch/s390/mm/gmap.c void s390_reset_acc(struct mm_struct *mm) · line 2768
Quoted 6 lines
arch/s390/mm/gmap.c +6
-0+ + page =alloc_pages (GFP_KERNEL_ACCOUNT ,CRST_ALLOC_ORDER ); +if (!page) +return -ENOMEM ; + table =page_to_virt (page); +memcpy (table, gmap->table,1UL << (CRST_ALLOC_ORDER +PAGE_SHIFT ));Is concurrent modification of
*gmap->tablepossible during the copy?
Quoted 5 lines
that would only be possible if the guest touches memory in such way that the table needs to be changed.
this function is only called when the guest is not running (e.g. during reboot), so nobody should touch the table
Is that asserted?
I guess if modifications to the table are block concurrent and entries are only freed when the vm is destroyed you cannot intentionally do any funny business.
Quoted 23 lines
Quoted 22 lines
Quoted 21 lines
arch/s390/mm/gmap.c +19
-0+ +/* +* The caller has to deal with the old ASCE, but here we make sure +* the new one is properly added to the list of page tables, so that +* it will be freed when the VM is torn down. +*/ +spin_lock (&gmap->guest_table_lock); +list_add (&page->lru, &gmap->crst_list); +spin_unlock (&gmap->guest_table_lock); + +/* Set new table origin while preserving existing ASCE control bits */ + asce = (gmap->asce & _ASCE_ORIGIN) |__pa (table); +WRITE_ONCE (gmap->asce, asce); +WRITE_ONCE (gmap->mm->context.gmap_asce, asce); +WRITE_ONCE (gmap->table, table); + +return 0 ; +} +EXPORT_SYMBOL_GPL (s390_replace_asce);
Claudio Imbrenda
maintainerPATCH v8 2/17 KVM: s390: pv: handle secure storage violations for protected guests
In reply to Claudio ImbrendaWith upcoming patches, protected guests will be able to trigger secure storage violations in normal operation.
A secure storage violation is triggered when a protected guest tries to access secure memory that has been mapped erroneously, or that belongs to a different protected guest or to the ultravisor.
With upcoming patches, protected guests will be able to trigger secure storage violations in normal operation. This happens for example if a protected guest is rebooted with lazy destroy enabled and the new guest is also protected.
When the new protected guest touches pages that have not yet been destroyed, and thus are accounted to the previous protected guest, a secure storage violation is raised.
This patch adds handling of secure storage violations for protected guests.
This exception is handled by first trying to destroy the page, because it is expected to belong to a defunct protected guest where a destroy should be possible. If that fails, a normal export of the page is attempted.
Therefore, pages that trigger the exception will be made non-secure before attempting to use them again for a different secure guest.
--- arch/s390/include/asm/uv.h | 1 + arch/s390/kernel/uv.c | 55 ++++++++++++++++++++++++++++++++++++++ arch/s390/mm/fault.c | 10 +++++++ 3 files changed, 66 insertions(+)
arch/s390/include/asm/uv.h +1 -0
@@ -356,6 +356,7 @@ static inline int is_prot_virt_host(void) }int gmap_make_secure (struct gmap *gmap,unsigned long gaddr,void *uvcb); +int gmap_destroy_page (struct gmap *gmap,unsigned long gaddr);int uv_destroy_owned_page (unsigned long paddr);int uv_convert_from_secure (unsigned long paddr);int uv_convert_owned_from_secure (unsigned long paddr);
arch/s390/kernel/uv.c +55 -0
61 lines not on this page · raw message
arch/s390/mm/fault.c +10 -0
@@ -853,6 +853,16 @@ NOKPROBE_SYMBOL(do_non_secure_storage_access);void do_secure_storage_violation (struct pt_regs *regs) { +unsigned long gaddr = regs->int_parm_long & __FAIL_ADDR_MASK; +struct gmap *gmap = (struct gmap *)S390_lowcore.gmap; + +/* +* If the VM has been rebooted, its address space might still contain +* secure pages from the previous boot. +* Clear the page so it can be reused. +*/ +if (!gmap_destroy_page (gmap, gaddr)) +return ;/* * Either KVM messed up the secure guest mapping or the same * page is mapped into multiple secure guests.
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 3/17 KVM: s390: pv: handle secure storage exceptions for normal guests
In reply to Claudio ImbrendaWith upcoming patches, normal guests might touch secure pages.
This patch extends the existing exception handler to convert the pages to non secure also when the exception is triggered by a normal guest.
This can happen for example when a secure guest reboots; the first stage of a secure guest is non secure, and in general a secure guest can reboot into non-secure mode.
If the secure memory of the previous boot has not been cleared up completely yet (which will be allowed to happen in an upcoming patch), a non-secure guest might touch secure memory, which will need to be handled properly.
--- arch/s390/mm/fault.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
arch/s390/mm/fault.c +12 -1
@@ -770,6 +770,7 @@ void do_secure_storage_access(struct pt_regs *regs)struct vm_area_struct *vma;struct mm_struct *mm;struct page *page; +struct gmap *gmap;int rc;/*
@@ -799,6 +800,17 @@ void do_secure_storage_access(struct pt_regs *regs) }switch (get_fault_type (regs)) { +case GMAP_FAULT : + mm = current->mm; + gmap = (struct gmap *)S390_lowcore.gmap; +mmap_read_lock (mm); + addr =__gmap_translate (gmap, addr); +mmap_read_unlock (mm); +if (IS_ERR_VALUE (addr)) { +do_fault_error (regs,VM_ACCESS_FLAGS ,VM_FAULT_BADMAP ); +break ; + } + fallthrough;case USER_FAULT : mm = current->mm;mmap_read_lock (mm);
@@ -827,7 +839,6 @@ void do_secure_storage_access(struct pt_regs *regs)if (rc)BUG ();break ; -case GMAP_FAULT :default :do_fault_error (regs,VM_READ |VM_WRITE ,VM_FAULT_BADMAP );WARN_ON_ONCE (1 );
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 4/17 KVM: s390: pv: refactor s390_reset_acc
In reply to Claudio ImbrendaRefactor s390_reset_acc so that it can be reused in upcoming patches.
We don't want to hold all the locks used in a walk_page_range for too long, and the destroy page UVC does take some time to complete. Therefore we quickly gather the pages to destroy, and then destroy them without holding all the locks.
The new refactored function optionally allows to return early without completing if a fatal signal is pending (and return and appropriate error code). Two wrappers are provided to call the new function.
(dropping Janosch's Ack because of major changes to the patch)
--- arch/s390/include/asm/gmap.h | 37 +++++++++++++- arch/s390/kvm/pv.c | 12 ++++- arch/s390/mm/gmap.c | 95 +++++++++++++++++++++++++----------- 3 files changed, 112 insertions(+), 32 deletions(-)
arch/s390/include/asm/gmap.h +36 -1
@@ -147,7 +147,42 @@ int gmap_mprotect_notify(struct gmap *, unsigned long start,void gmap_sync_dirty_log_pmd (struct gmap *gmap,unsigned long dirty_bitmap[4 ],unsigned long gaddr,unsigned long vmaddr);int gmap_mark_unmergeable (void ); -void s390_reset_acc (struct mm_struct *mm);void s390_remove_old_asce (struct gmap *gmap);int s390_replace_asce (struct gmap *gmap); +void s390_uv_destroy_pfns (unsigned long count,unsigned long *pfns); +int __s390_uv_destroy_range (struct mm_struct *mm,unsigned long start, +unsigned long end,bool interruptible); + +/** +* s390_uv_destroy_range - Destroy a range of pages in the given mm. +* @mm the mm on which to operate on +* @start the start of the range +* @end the end of the range +* +* This function will call cond_sched, so it should not generate stalls, but +* it will otherwise only return when it completed. +*/ +static inline void s390_uv_destroy_range (struct mm_struct *mm,unsigned long start, +unsigned long end) +{ + (void )__s390_uv_destroy_range (mm, start, end, false); +} + +/** +* s390_uv_destroy_range_interruptible - Destroy a range of pages in the +* given mm, but stop when a fatal signal is received. +* @mm the mm on which to operate on +* @start the start of the range +* @end the end of the range +* +* This function will call cond_sched, so it should not generate stalls. If +* a fatal signal is received, it will return with -EINTR immediately, +* without finishing destroying the whole range. Upon successful +* completion, 0 is returned. +*/ +static inline int s390_uv_destroy_range_interruptible (struct mm_struct *mm,unsigned long start, +unsigned long end) +{ +return __s390_uv_destroy_range (mm, start, end, true); +}#endif /* _ASM_S390_GMAP_H */
arch/s390/kvm/pv.c +10 -2
@@ -12,6 +12,8 @@#include <asm/gmap.h> #include <asm/uv.h> #include <asm/mman.h> +#include <linux/pagewalk.h> +#include <linux/sched/mm.h> #include "kvm-s390.h" int kvm_s390_pv_destroy_cpu (struct kvm_vcpu *vcpu,u16 *rc,u16 *rrc)
@@ -157,8 +159,14 @@ int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc) {int cc; -/* make all pages accessible before destroying the guest */ -s390_reset_acc (kvm->mm); +/* +* if the mm still has a mapping, make all its pages accessible +* before destroying the guest +*/ +if (mmget_not_zero (kvm->mm)) { +s390_uv_destroy_range (kvm->mm,0 ,TASK_SIZE ); +mmput (kvm->mm); + } cc =uv_cmd_nodata (kvm_s390_pv_get_handle (kvm),UVC_CMD_DESTROY_SEC_CONF , rc, rrc);
arch/s390/mm/gmap.c +66 -29
110 lines not on this page · raw message
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 5/17 KVM: s390: pv: usage counter instead of flag
In reply to Claudio ImbrendaUse the new protected_count field as a counter instead of the old is_protected flag. This will be used in upcoming patches.
Increment the counter when a secure configuration is created, and decrement it when it is destroyed. Previously the flag was set when the set secure parameters UVC was performed.
--- arch/s390/include/asm/mmu.h | 2 +- arch/s390/include/asm/mmu_context.h | 2 +- arch/s390/include/asm/pgtable.h | 2 +- arch/s390/kvm/pv.c | 12 +++++++----- 4 files changed, 10 insertions(+), 8 deletions(-)
arch/s390/include/asm/mmu.h +1 -1
@@ -17,7 +17,7 @@ typedef struct {unsigned long asce_limit;unsigned long vdso_base;/* The mmu context belongs to a secure guest. */ -atomic_t is_protected; +atomic_t protected_count;/* * The following bitfields need a down_write on the mm * semaphore when they are written to. As they are only
arch/s390/include/asm/mmu_context.h +1 -1
@@ -26,7 +26,7 @@ static inline int init_new_context(struct task_struct *tsk,INIT_LIST_HEAD (&mm->context.gmap_list);cpumask_clear (&mm->context.cpu_attach_mask);atomic_set (&mm->context.flush_count,0 ); -atomic_set (&mm->context.is_protected,0 ); +atomic_set (&mm->context.protected_count,0 ); mm->context.gmap_asce =0 ; mm->context.flush_mm =0 ;#ifdef CONFIG_PGSTE
arch/s390/include/asm/pgtable.h +1 -1
@@ -523,7 +523,7 @@ static inline int mm_has_pgste(struct mm_struct *mm)static inline int mm_is_protected (struct mm_struct *mm) {#ifdef CONFIG_PGSTE -if (unlikely (atomic_read (&mm->context.is_protected))) +if (unlikely (atomic_read (&mm->context.protected_count)))return 1 ;#endif return 0 ;
arch/s390/kvm/pv.c +7 -5
@@ -171,7 +171,8 @@ int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc) cc =uv_cmd_nodata (kvm_s390_pv_get_handle (kvm),UVC_CMD_DESTROY_SEC_CONF , rc, rrc);WRITE_ONCE (kvm->arch.gmap->guest_handle,0 ); -atomic_set (&kvm->mm->context.is_protected,0 ); +if (!cc) +atomic_dec (&kvm->mm->context.protected_count);KVM_UV_EVENT (kvm,3 ,"PROTVIRT DESTROY VM: rc %x rrc %x" , *rc, *rrc);WARN_ONCE (cc,"protvirt destroy vm failed rc %x rrc %x" , *rc, *rrc);/* Intended memory leak on "impossible" error */
@@ -213,11 +214,14 @@ int kvm_s390_pv_init_vm(struct kvm *kvm, u16 *rc, u16 *rrc)/* Outputs */ kvm->arch.pv.handle = uvcb.guest_handle; +atomic_inc (&kvm->mm->context.protected_count);if (cc) { -if (uvcb.header.rc &UVC_RC_NEED_DESTROY ) +if (uvcb.header.rc &UVC_RC_NEED_DESTROY ) {kvm_s390_pv_deinit_vm (kvm, &dummy, &dummy); -else + }else { +atomic_dec (&kvm->mm->context.protected_count);kvm_s390_pv_dealloc_vm (kvm); + }return -EIO ; } kvm->arch.gmap->guest_handle = uvcb.guest_handle;
@@ -240,8 +244,6 @@ int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc, *rrc = uvcb.header.rrc;KVM_UV_EVENT (kvm,3 ,"PROTVIRT VM SET PARMS: rc %x rrc %x" , *rc, *rrc); -if (!cc) -atomic_set (&kvm->mm->context.is_protected,1 );return cc ? -EINVAL :0 ; }
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 6/17 KVM: s390: pv: add export before import
In reply to Claudio ImbrendaDue to upcoming changes, it will be possible to temporarily have multiple protected VMs in the same address space, although only one will be actually active.
In that scenario, it is necessary to perform an export of every page that is to be imported, since the hardware does not allow a page belonging to a protected guest to be imported into a different protected guest.
This also applies to pages that are shared, and thus accessible by the host.
--- arch/s390/kernel/uv.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/s390/kernel/uv.c +8 -0
@@ -234,6 +234,12 @@ static int make_secure_pte(pte_t *ptep, unsigned long addr,return uvcb->rc ==0x10a ? -ENXIO : -EINVAL ; } +static bool should_export_before_import (struct uv_cb_header *uvcb,struct mm_struct *mm) +{ +return uvcb->cmd !=UVC_CMD_UNPIN_PAGE_SHARED && +atomic_read (&mm->context.protected_count) >1 ; +} +/* * Requests the Ultravisor to make a page accessible to a guest. * If it's brought in the first time, it will be cleared. If
@@ -277,6 +283,8 @@ int gmap_make_secure(struct gmap *gmap, unsigned long gaddr, void *uvcb)lock_page (page); ptep =get_locked_pte (gmap->mm, uaddr, &ptelock); +if (should_export_before_import (uvcb, gmap->mm)) +uv_convert_from_secure (page_to_phys (page)); rc =make_secure_pte (ptep, uaddr, page, uvcb);pte_unmap_unlock (ptep, ptelock);unlock_page (page);
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 7/17 KVM: s390: pv: module parameter to fence lazy destroy
In reply to Claudio ImbrendaAdd the module parameter "lazy_destroy", to allow the asynchronous destroy mechanism to be switched off. This might be useful for debugging purposes.
The parameter is enabled by default.
--- arch/s390/kvm/kvm-s390.c | 5 +++++ 1 file changed, 5 insertions(+)
arch/s390/kvm/kvm-s390.c +5 -0
@@ -207,6 +207,11 @@ unsigned int diag9c_forwarding_hz;module_param (diag9c_forwarding_hz, uint,0644 );MODULE_PARM_DESC (diag9c_forwarding_hz,"Maximum diag9c forwarding per second, 0 to turn off" ); +/* allow asynchronous deinit for protected guests */ +static int lazy_destroy =1 ; +module_param (lazy_destroy, int,0444 ); +MODULE_PARM_DESC (lazy_destroy,"Asynchronous destroy for protected guests" ); +/* * For now we handle at most 16 double words as this is what the s390 base * kernel handles and stores in the prefix page. If we ever need to go beyond
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 8/17 KVM: s390: pv: clear the state without memset
In reply to Claudio ImbrendaDo not use memset to clean the whole struct kvm_s390_pv; instead, explicitly clear the fields that need to be cleared.
Upcoming patches will introduce new fields in the struct kvm_s390_pv that will not need to be cleared.
--- arch/s390/kvm/pv.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-)
arch/s390/kvm/pv.c +9 -1
@@ -16,6 +16,14 @@#include <linux/sched/mm.h> #include "kvm-s390.h" +static void kvm_s390_clear_pv_state (struct kvm *kvm) +{ + kvm->arch.pv.handle =0 ; + kvm->arch.pv.guest_len =0 ; + kvm->arch.pv.stor_base =0 ; + kvm->arch.pv.stor_var =NULL ; +} +int kvm_s390_pv_destroy_cpu (struct kvm_vcpu *vcpu,u16 *rc,u16 *rrc) {int cc;
@@ -110,7 +118,7 @@ static void kvm_s390_pv_dealloc_vm(struct kvm *kvm)vfree (kvm->arch.pv.stor_var);free_pages (kvm->arch.pv.stor_base,get_order (uv_info.guest_base_stor_len)); -memset (&kvm->arch.pv,0 ,sizeof (kvm->arch.pv)); +kvm_s390_clear_pv_state (kvm); }static int kvm_s390_pv_alloc_vm (struct kvm *kvm)
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 9/17 KVM: s390: pv: Add kvm_s390_cpus_from_pv to kvm-s390.h and add documentation
In reply to Claudio ImbrendaFuture changes make it necessary to call this function from pv.c.
While we are at it, let's properly document kvm_s390_cpus_from_pv() and kvm_s390_cpus_to_pv().
--- arch/s390/kvm/kvm-s390.c | 26 +++++++++++++++++++++++++- arch/s390/kvm/kvm-s390.h | 1 + 2 files changed, 26 insertions(+), 1 deletion(-)
arch/s390/kvm/kvm-s390.c +25 -1
@@ -2175,7 +2175,20 @@ static int kvm_s390_set_cmma_bits(struct kvm *kvm,return r; } -static int kvm_s390_cpus_from_pv (struct kvm *kvm,u16 *rcp,u16 *rrcp) +/** +* kvm_s390_cpus_from_pv - Convert all protected vCPUs in a protected VM to +* non protected. +* @kvm the VM whose protected vCPUs are to be converted +* @rcp return value for the RC field of the UVC (in case of error) +* @rrcp return value for the RRC field of the UVC (in case of error) +* +* Does not stop in case of error, tries to convert as many +* CPUs as possible. In case of error, the RC and RRC of the last error are +* returned. +* +* Return: 0 in case of success, otherwise -EIO +*/ +int kvm_s390_cpus_from_pv (struct kvm *kvm,u16 *rcp,u16 *rrcp) {struct kvm_vcpu *vcpu;u16 rc, rrc;
@@ -2202,6 +2215,17 @@ static int kvm_s390_cpus_from_pv(struct kvm *kvm, u16 *rcp, u16 *rrcp)return ret; } +/** +* kvm_s390_cpus_to_pv - Convert all non-protected vCPUs in a protected VM +* to protected. +* @kvm the VM whose protected vCPUs are to be converted +* @rcp return value for the RC field of the UVC (in case of error) +* @rrcp return value for the RRC field of the UVC (in case of error) +* +* Tries to undo the conversion in case of error. +* +* Return: 0 in case of success, otherwise -EIO +*/ static int kvm_s390_cpus_to_pv (struct kvm *kvm,u16 *rc,u16 *rrc) {unsigned long i;
arch/s390/kvm/kvm-s390.h +1 -0
@@ -365,6 +365,7 @@ int kvm_s390_vcpu_setup_cmma(struct kvm_vcpu *vcpu);void kvm_s390_vcpu_unsetup_cmma (struct kvm_vcpu *vcpu);void kvm_s390_set_cpu_timer (struct kvm_vcpu *vcpu,__u64 cputm);__u64 kvm_s390_get_cpu_timer (struct kvm_vcpu *vcpu); +int kvm_s390_cpus_from_pv (struct kvm *kvm,u16 *rcp,u16 *rrcp);/* implemented in diag.c */ int kvm_s390_handle_diag (struct kvm_vcpu *vcpu);
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 10/17 KVM: s390: pv: add mmu_notifier
In reply to Claudio ImbrendaAdd an mmu_notifier for protected VMs. The callback function is triggered when the mm is torn down, and will attempt to convert all protected vCPUs to non-protected. This allows the mm teardown to use the destroy page UVC instead of export.
--- arch/s390/include/asm/kvm_host.h | 2 ++ arch/s390/kvm/kvm-s390.c | 5 ++++- arch/s390/kvm/pv.c | 26 ++++++++++++++++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-)
arch/s390/include/asm/kvm_host.h +2 -0
@@ -19,6 +19,7 @@#include <linux/kvm.h> #include <linux/seqlock.h> #include <linux/module.h> +#include <linux/mmu_notifier.h> #include <asm/debug.h> #include <asm/cpu.h> #include <asm/fpu/api.h>
@@ -921,6 +922,7 @@ struct kvm_s390_pv {u64 guest_len;unsigned long stor_base;void *stor_var; +struct mmu_notifier mmu_notifier; };struct kvm_arch {
arch/s390/kvm/kvm-s390.c +4 -1
@@ -32,6 +32,7 @@#include <linux/sched/signal.h> #include <linux/string.h> #include <linux/pgtable.h> +#include <linux/mmu_notifier.h> #include <asm/asm-offsets.h> #include <asm/lowcore.h>
@@ -2833,8 +2834,10 @@ void kvm_arch_destroy_vm(struct kvm *kvm)* can mess with the pv state. To avoid lockdep_assert_held from * complaining we do not use kvm_s390_pv_is_protected. */ -if (kvm_s390_pv_get_handle (kvm)) +if (kvm_s390_pv_get_handle (kvm)) {kvm_s390_pv_deinit_vm (kvm, &rc, &rrc); +mmu_notifier_unregister (&kvm->arch.pv.mmu_notifier, kvm->mm); + }debug_unregister (kvm->arch.dbf);free_page ((unsigned long )kvm->arch.sie_page2);if (!kvm_is_ucontrol (kvm))
arch/s390/kvm/pv.c +26 -0
@@ -14,6 +14,7 @@#include <asm/mman.h> #include <linux/pagewalk.h> #include <linux/sched/mm.h> +#include <linux/mmu_notifier.h> #include "kvm-s390.h" static void kvm_s390_clear_pv_state (struct kvm *kvm)
@@ -192,6 +193,26 @@ int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc)return -EIO ; } +static void kvm_s390_pv_mmu_notifier_release (struct mmu_notifier *subscription, +struct mm_struct *mm) +{ + struct kvm *kvm = container_of(subscription, struct kvm, arch.pv.mmu_notifier); +u16 dummy; + +/* +* No locking is needed since this is the last thread of the last user of this +* struct mm. +* When the struct kvm gets deinitialized, this notifier is also +* unregistered. This means that if this notifier runs, then the +* struct kvm is still valid. +*/ +kvm_s390_cpus_from_pv (kvm, &dummy, &dummy); +} + +static const struct mmu_notifier_ops kvm_s390_pv_mmu_notifier_ops = { + .release = kvm_s390_pv_mmu_notifier_release, +}; +int kvm_s390_pv_init_vm (struct kvm *kvm,u16 *rc,u16 *rrc) {struct uv_cb_cgc uvcb = {
@@ -233,6 +254,11 @@ int kvm_s390_pv_init_vm(struct kvm *kvm, u16 *rc, u16 *rrc)return -EIO ; } kvm->arch.gmap->guest_handle = uvcb.guest_handle; +/* Add the notifier only once. No races because we hold kvm->lock */ +if (kvm->arch.pv.mmu_notifier.ops != &kvm_s390_pv_mmu_notifier_ops) { + kvm->arch.pv.mmu_notifier.ops = &kvm_s390_pv_mmu_notifier_ops; +mmu_notifier_register (&kvm->arch.pv.mmu_notifier, kvm->mm); + }return 0 ; }
Signature · 1 line
2.34.1
kernel test robot
build botRe: [PATCH v8 10/17] KVM: s390: pv: add mmu_notifier
I love your patch! Yet something to improve:
Hi Claudio,
I love your patch! Yet something to improve:
[auto build test ERROR on kvm/master]
[also build test ERROR on v5.17-rc6 next-20220302]
[cannot apply to kvms390/next s390/features]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Claudio-Imbrenda/KVM-s390-pv-implement-lazy-destroy-for-reboot/20220303-021407 base: https://git.kernel.org/pub/scm/virt/kvm/kvm.git master config: s390-buildonly-randconfig-r006-20220302 (https://download.01.org/0day-ci/archive/20220303/[email protected]/config) compiler: s390-linux-gcc (GCC) 11.2.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/bbf278ea47b7bdfb3c72e24faffedbb8a3a5b9f9
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Claudio-Imbrenda/KVM-s390-pv-implement-lazy-destroy-for-reboot/20220303-021407 git checkout bbf278ea47b7bdfb3c72e24faffedbb8a3a5b9f9
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-11.2.0 make.cross O=build_dir ARCH=s390 SHELL=/bin/bash arch/s390/kvm/
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
arch/s390/kvm/kvm-s390.c: In function 'kvm_arch_destroy_vm':
>> arch/s390/kvm/kvm-s390.c:2839:17: error: implicit declaration of function 'mmu_notifier_unregister'; did you mean 'preempt_notifier_unregister'? [-Werror=implicit-function-declaration]
2839 | mmu_notifier_unregister(&kvm->arch.pv.mmu_notifier, kvm->mm);
| ^~~~~~~~~~~~~~~~~~~~~~~
| preempt_notifier_unregister
cc1: some warnings being treated as errors
--
arch/s390/kvm/pv.c: In function 'kvm_s390_pv_init_vm':
>> arch/s390/kvm/pv.c:260:17: error: implicit declaration of function 'mmu_notifier_register'; did you mean 'mmu_notifier_release'? [-Werror=implicit-function-declaration]
260 | mmu_notifier_register(&kvm->arch.pv.mmu_notifier, kvm->mm);
| ^~~~~~~~~~~~~~~~~~~~~
| mmu_notifier_releasecc1: some warnings being treated as errors
vim +2839 arch/s390/kvm/kvm-s390.c
2823
2824 void kvm_arch_destroy_vm(struct kvm *kvm)
2825 {
2826 u16 rc, rrc;
2827
2828 kvm_destroy_vcpus(kvm);
2829 sca_dispose(kvm);
2830 kvm_s390_gisa_destroy(kvm);
2831 /*
2832 * We are already at the end of life and kvm->lock is not taken.
2833 * This is ok as the file descriptor is closed by now and nobody
2834 * can mess with the pv state. To avoid lockdep_assert_held from
2835 * complaining we do not use kvm_s390_pv_is_protected.
2836 */
2837 if (kvm_s390_pv_get_handle(kvm)) {
2838 kvm_s390_pv_deinit_vm(kvm, &rc, &rrc);
> 2839 mmu_notifier_unregister(&kvm->arch.pv.mmu_notifier, kvm->mm);
2840 }
2841 debug_unregister(kvm->arch.dbf);
2842 free_page((unsigned long)kvm->arch.sie_page2);
2843 if (!kvm_is_ucontrol(kvm))
2844 gmap_remove(kvm->arch.gmap);
2845 kvm_s390_destroy_adapters(kvm);
2846 kvm_s390_clear_float_irqs(kvm);
2847 kvm_s390_vsie_destroy(kvm);
2848 KVM_EVENT(3, "vm 0x%pK destroyed", kvm);
2849 }
2850
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
kernel test robot
build botRe: [PATCH v8 10/17] KVM: s390: pv: add mmu_notifier
In reply to Claudio ImbrendaI love your patch! Yet something to improve:
Hi Claudio,
I love your patch! Yet something to improve:
[auto build test ERROR on kvm/master]
[also build test ERROR on v5.17-rc6 next-20220302]
[cannot apply to kvms390/next s390/features]
[If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Claudio-Imbrenda/KVM-s390-pv-implement-lazy-destroy-for-reboot/20220303-021407 base: https://git.kernel.org/pub/scm/virt/kvm/kvm.git master config: s390-randconfig-r001-20220302 (https://download.01.org/0day-ci/archive/20220303/[email protected]/config) compiler: clang version 15.0.0 (https://github.com/llvm/llvm-project d271fc04d5b97b12e6b797c6067d3c96a8d7470e)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install s390 cross compiling tool for clang build
# apt-get install binutils-s390x-linux-gnu
# https://github.com/0day-ci/linux/commit/bbf278ea47b7bdfb3c72e24faffedbb8a3a5b9f9
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Claudio-Imbrenda/KVM-s390-pv-implement-lazy-destroy-for-reboot/20220303-021407 git checkout bbf278ea47b7bdfb3c72e24faffedbb8a3a5b9f9
# save the config file to linux build tree
mkdir build_dir
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=s390 SHELL=/bin/bash arch/s390/kvm/
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
In file included from arch/s390/kvm/kvm-s390.c:23:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:464:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __raw_readb(PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:37:59: note: expanded from macro '__le16_to_cpu'
#define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x))
^
include/uapi/linux/swab.h:102:54: note: expanded from macro '__swab16'
#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
^
In file included from arch/s390/kvm/kvm-s390.c:23:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:35:59: note: expanded from macro '__le32_to_cpu'
#define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
^
include/uapi/linux/swab.h:115:54: note: expanded from macro '__swab32'
#define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
^
In file included from arch/s390/kvm/kvm-s390.c:23:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writeb(value, PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
>> arch/s390/kvm/kvm-s390.c:2839:3: error: implicit declaration of function 'mmu_notifier_unregister' [-Werror,-Wimplicit-function-declaration]
mmu_notifier_unregister(&kvm->arch.pv.mmu_notifier, kvm->mm);
^
arch/s390/kvm/kvm-s390.c:2839:3: note: did you mean 'preempt_notifier_unregister'?
include/linux/preempt.h:346:6: note: 'preempt_notifier_unregister' declared here
void preempt_notifier_unregister(struct preempt_notifier *notifier);
^ 12 warnings and 1 error generated.
--
In file included from arch/s390/kvm/pv.c:9:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:464:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __raw_readb(PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:37:59: note: expanded from macro '__le16_to_cpu'
#define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x))
^
include/uapi/linux/swab.h:102:54: note: expanded from macro '__swab16'
#define __swab16(x) (__u16)__builtin_bswap16((__u16)(x))
^
In file included from arch/s390/kvm/pv.c:9:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/big_endian.h:35:59: note: expanded from macro '__le32_to_cpu'
#define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x))
^
include/uapi/linux/swab.h:115:54: note: expanded from macro '__swab32'
#define __swab32(x) (__u32)__builtin_bswap32((__u32)(x))
^
In file included from arch/s390/kvm/pv.c:9:
In file included from include/linux/kvm_host.h:41:
In file included from include/linux/kvm_para.h:5:
In file included from include/uapi/linux/kvm_para.h:37:
In file included from arch/s390/include/asm/kvm_para.h:25:
In file included from arch/s390/include/asm/diag.h:12:
In file included from include/linux/if_ether.h:19:
In file included from include/linux/skbuff.h:31:
In file included from include/linux/dma-mapping.h:10:
In file included from include/linux/scatterlist.h:9:
In file included from arch/s390/include/asm/io.h:75:
include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writeb(value, PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
>> arch/s390/kvm/pv.c:260:3: error: implicit declaration of function 'mmu_notifier_register' [-Werror,-Wimplicit-function-declaration]
mmu_notifier_register(&kvm->arch.pv.mmu_notifier, kvm->mm);
^
arch/s390/kvm/pv.c:260:3: note: did you mean 'mmu_notifier_release'?
include/linux/mmu_notifier.h:679:20: note: 'mmu_notifier_release' declared here
static inline void mmu_notifier_release(struct mm_struct *mm)
^12 warnings and 1 error generated.
vim +/mmu_notifier_unregister +2839 arch/s390/kvm/kvm-s390.c
2823
2824 void kvm_arch_destroy_vm(struct kvm *kvm)
2825 {
2826 u16 rc, rrc;
2827
2828 kvm_destroy_vcpus(kvm);
2829 sca_dispose(kvm);
2830 kvm_s390_gisa_destroy(kvm);
2831 /*
2832 * We are already at the end of life and kvm->lock is not taken.
2833 * This is ok as the file descriptor is closed by now and nobody
2834 * can mess with the pv state. To avoid lockdep_assert_held from
2835 * complaining we do not use kvm_s390_pv_is_protected.
2836 */
2837 if (kvm_s390_pv_get_handle(kvm)) {
2838 kvm_s390_pv_deinit_vm(kvm, &rc, &rrc);
> 2839 mmu_notifier_unregister(&kvm->arch.pv.mmu_notifier, kvm->mm);
2840 }
2841 debug_unregister(kvm->arch.dbf);
2842 free_page((unsigned long)kvm->arch.sie_page2);
2843 if (!kvm_is_ucontrol(kvm))
2844 gmap_remove(kvm->arch.gmap);
2845 kvm_s390_destroy_adapters(kvm);
2846 kvm_s390_clear_float_irqs(kvm);
2847 kvm_s390_vsie_destroy(kvm);
2848 KVM_EVENT(3, "vm 0x%pK destroyed", kvm);
2849 }
2850
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
Claudio Imbrenda
maintainerPATCH v8 11/17 s390/mm: KVM: pv: when tearing down, try to destroy protected pages
In reply to Claudio ImbrendaWhen ptep_get_and_clear_full is called for a mm teardown, we will now attempt to destroy the secure pages. This will be faster than export.
In case it was not a teardown, or if for some reason the destroy page UVC failed, we try with an export page, like before.
--- arch/s390/include/asm/pgtable.h | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-)
arch/s390/include/asm/pgtable.h +15 -3
@@ -1118,9 +1118,21 @@ static inline pte_t ptep_get_and_clear_full(struct mm_struct *mm, }else { res =ptep_xchg_lazy (mm, addr, ptep,__pte (_PAGE_INVALID)); } -/* At this point the reference through the mapping is still present */ -if (mm_is_protected (mm) &&pte_present (res)) -uv_convert_owned_from_secure (pte_val (res) &PAGE_MASK ); +/* Nothing to do */ +if (!mm_is_protected (mm) || !pte_present (res)) +return res; +/* +* At this point the reference through the mapping is still present. +* The notifier should have destroyed all protected vCPUs at this +* point, so the destroy should be successful. +*/ +if (full && !uv_destroy_owned_page (pte_val (res) &PAGE_MASK )) +return res; +/* +* But if something went wrong and the pages could not be destroyed, +* the slower export is used as fallback instead. +*/ +uv_convert_owned_from_secure (pte_val (res) &PAGE_MASK );return res; }
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 12/17 KVM: s390: pv: refactoring of kvm_s390_pv_deinit_vm
In reply to Claudio ImbrendaRefactor kvm_s390_pv_deinit_vm to improve readability and simplify the improvements that are coming in subsequent patches.
No functional change intended.
[note: this can potentially be squashed into the next patch, I factored it out to simplify the review process]
--- arch/s390/kvm/pv.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
arch/s390/kvm/pv.c +8 -8
@@ -180,17 +180,17 @@ int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc) cc =uv_cmd_nodata (kvm_s390_pv_get_handle (kvm),UVC_CMD_DESTROY_SEC_CONF , rc, rrc);WRITE_ONCE (kvm->arch.gmap->guest_handle,0 ); -if (!cc) -atomic_dec (&kvm->mm->context.protected_count); -KVM_UV_EVENT (kvm,3 ,"PROTVIRT DESTROY VM: rc %x rrc %x" , *rc, *rrc); -WARN_ONCE (cc,"protvirt destroy vm failed rc %x rrc %x" , *rc, *rrc); -/* Intended memory leak on "impossible" error */ if (!cc) { +atomic_dec (&kvm->mm->context.protected_count);kvm_s390_pv_dealloc_vm (kvm); -return 0 ; + }else { +/* Intended memory leak on "impossible" error */ +s390_replace_asce (kvm->arch.gmap); } -s390_replace_asce (kvm->arch.gmap); -return -EIO ; +KVM_UV_EVENT (kvm,3 ,"PROTVIRT DESTROY VM: rc %x rrc %x" , *rc, *rrc); +WARN_ONCE (cc,"protvirt destroy vm failed rc %x rrc %x" , *rc, *rrc); + +return cc ? -EIO :0 ; } static void kvm_s390_pv_mmu_notifier_release(struct mmu_notifier *subscription,
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 13/17 KVM: s390: pv: cleanup leftover protected VMs if needed
In reply to Claudio ImbrendaIn upcoming patches it will be possible to start tearing down a protected VM, and finish the teardown concurrently in a different thread.
Protected VMs that are pending for tear down ("leftover") need to be cleaned properly when the userspace process (e.g. qemu) terminates.
This patch makes sure that all "leftover" protected VMs are always properly torn down.
--- arch/s390/include/asm/kvm_host.h | 2 + arch/s390/kvm/kvm-s390.c | 1 + arch/s390/kvm/pv.c | 69 ++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+)
arch/s390/include/asm/kvm_host.h +2 -0
@@ -922,6 +922,8 @@ struct kvm_s390_pv {u64 guest_len;unsigned long stor_base;void *stor_var; +void *async_deinit; +struct list_head need_cleanup;struct mmu_notifier mmu_notifier; };
arch/s390/kvm/kvm-s390.c +1 -0
@@ -2788,6 +2788,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)kvm_s390_vsie_init (kvm);if (use_gisa)kvm_s390_gisa_init (kvm); +INIT_LIST_HEAD (&kvm->arch.pv.need_cleanup);KVM_EVENT (3 ,"vm 0x%pK created by pid %u" , kvm, current->pid);return 0 ;
arch/s390/kvm/pv.c +69 -0
87 lines not on this page · raw message
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 14/17 KVM: s390: pv: asynchronous destroy for reboot
In reply to Claudio ImbrendaUntil now, destroying a protected guest was an entirely synchronous operation that could potentially take a very long time, depending on the size of the guest, due to the time needed to clean up the address space from protected pages.
This patch implements an asynchronous destroy mechanism, that allows a protected guest to reboot significantly faster than previously.
This is achieved by clearing the pages of the old guest in background. In case of reboot, the new guest will be able to run in the same address space almost immediately.
The old protected guest is then only destroyed when all of its memory has been destroyed or otherwise made non protected.
Two new PV commands are added for the KVM_S390_PV_COMMAND ioctl:
KVM_PV_ASYNC_DISABLE_PREPARE: prepares the current protected VM for asynchronous teardown. The current VM will then continue immediately as non-protected. If a protected VM had already been set aside without starting the teardown process, this call will fail.
KVM_PV_ASYNC_DISABLE: tears down the protected VM previously set aside for asynchronous teardown. This PV command should ideally be issued by userspace from a separate thread. If a fatal signal is received (or the process terminates naturally), the command will terminate immediately without completing.
Leftover protected VMs are cleaned up when a KVM VM is torn down normally (either via IOCTL or when the process terminates); this cleanup has been implemented in a previous patch.
--- arch/s390/kvm/kvm-s390.c | 24 ++++++++ arch/s390/kvm/kvm-s390.h | 2 + arch/s390/kvm/pv.c | 126 +++++++++++++++++++++++++++++++++++++++ include/uapi/linux/kvm.h | 2 + 4 files changed, 154 insertions(+)
arch/s390/kvm/kvm-s390.c +24 -0
@@ -2285,6 +2285,30 @@ static int kvm_s390_handle_pv(struct kvm *kvm, struct kvm_pv_cmd *cmd)set_bit (IRQ_PEND_EXT_SERVICE , &kvm->arch.float_int.masked_irqs);break ; } +case KVM_PV_ASYNC_DISABLE_PREPARE : + r = -EINVAL ; +if (!kvm_s390_pv_is_protected (kvm) || !lazy_destroy) +break ; + + r =kvm_s390_cpus_from_pv (kvm, &cmd->rc, &cmd->rrc); +/* +* If a CPU could not be destroyed, destroy VM will also fail. +* There is no point in trying to destroy it. Instead return +* the rc and rrc from the first CPU that failed destroying. +*/ +if (r) +break ; + r =kvm_s390_pv_deinit_vm_async_prepare (kvm, &cmd->rc, &cmd->rrc); + +/* no need to block service interrupts any more */ +clear_bit (IRQ_PEND_EXT_SERVICE , &kvm->arch.float_int.masked_irqs); +break ; +case KVM_PV_ASYNC_DISABLE : + r = -EINVAL ; +if (!kvm->arch.pv.async_deinit) +break ; + r =kvm_s390_pv_deinit_vm_async (kvm, &cmd->rc, &cmd->rrc); +break ;case KVM_PV_DISABLE : { r = -EINVAL ;if (!kvm_s390_pv_is_protected (kvm))
arch/s390/kvm/kvm-s390.h +2 -0
@@ -234,6 +234,8 @@ static inline unsigned long kvm_s390_get_gfn_end(struct kvm_memslots *slots)/* implemented in pv.c */ int kvm_s390_pv_destroy_cpu (struct kvm_vcpu *vcpu,u16 *rc,u16 *rrc);int kvm_s390_pv_create_cpu (struct kvm_vcpu *vcpu,u16 *rc,u16 *rrc); +int kvm_s390_pv_deinit_vm_async_prepare (struct kvm *kvm,u16 *rc,u16 *rrc); +int kvm_s390_pv_deinit_vm_async (struct kvm *kvm,u16 *rc,u16 *rrc);int kvm_s390_pv_deinit_vm (struct kvm *kvm,u16 *rc,u16 *rrc);int kvm_s390_pv_init_vm (struct kvm *kvm,u16 *rc,u16 *rrc); int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,
arch/s390/kvm/pv.c +126 -0
132 lines not on this page · raw message
include/uapi/linux/kvm.h +2 -0
@@ -1644,6 +1644,8 @@ enum pv_cmd_id {KVM_PV_VERIFY ,KVM_PV_PREP_RESET ,KVM_PV_UNSHARE_ALL , +KVM_PV_ASYNC_DISABLE_PREPARE , + KVM_PV_ASYNC_DISABLE, }; struct kvm_pv_cmd {
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 15/17 KVM: s390: pv: api documentation for asynchronous destroy
In reply to Claudio ImbrendaAdd documentation for the new commands added to the KVM_S390_PV_COMMAND ioctl.
--- Documentation/virt/kvm/api.rst | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-)
Documentation/virt/kvm/api.rst +22 -3
@@ -5010,11 +5010,13 @@ KVM_PV_ENABLE ===== ============================= KVM_PV_DISABLE - Deregister the VM from the Ultravisor and reclaim the memory that had been donated to the Ultravisor, making it usable by the kernel - again. All registered VCPUs are converted back to non-protected - ones. + again. All registered VCPUs are converted back to non-protected + ones. If a previous VM had been prepared for asynchonous teardown + with KVM_PV_ASYNC_DISABLE_PREPARE and not actually torn down with + KVM_PV_ASYNC_DISABLE, it will be torn down in this call together with + the current VM. KVM_PV_VM_SET_SEC_PARMS Pass the image header from VM memory to the Ultravisor in
@@ -5027,6 +5029,23 @@ KVM_PV_VM_VERIFY Verify the integrity of the unpacked image. Only if this succeeds, KVM is allowed to start protected VCPUs. +KVM_PV_ASYNC_DISABLE_PREPARE + Prepare the current protected VM for asynchronous teardown. Most + resources used by the current protected VM will be set aside for a + subsequent asynchronous teardown. The current protected VM will then + resume execution immediately as non-protected. If a protected VM had + already been prepared without starting the asynchronous teardown process, + this call will fail. In that case, the userspace process should issue a + normal KVM_PV_DISABLE. + +KVM_PV_ASYNC_DISABLE + Tear down the protected VM previously prepared for asynchronous teardown. + The resources that had been set aside will be freed asynchronously during + the execution of this command. + This PV command should ideally be issued by userspace from a separate + thread. If a fatal signal is received (or the process terminates + naturally), the command will terminate immediately without completing. + 4.126 KVM_X86_SET_MSR_FILTER ----------------------------
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 16/17 KVM: s390: pv: add KVM_CAP_S390_PROTECTED_ASYNC_DISABLE
In reply to Claudio ImbrendaAdd KVM_CAP_S390_PROTECTED_ASYNC_DISABLE to signal that the KVM_PV_ASYNC_DISABLE and KVM_PV_ASYNC_DISABLE_PREPARE commands for the KVM_S390_PV_COMMAND ioctl are available.
--- arch/s390/kvm/kvm-s390.c | 3 +++ include/uapi/linux/kvm.h | 1 + 2 files changed, 4 insertions(+)
arch/s390/kvm/kvm-s390.c +3 -0
@@ -609,6 +609,9 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext)case KVM_CAP_S390_BPB : r =test_facility (82 );break ; +case KVM_CAP_S390_PROTECTED_ASYNC_DISABLE : + r = lazy_destroy &&is_prot_virt_host (); +break ;case KVM_CAP_S390_PROTECTED : r =is_prot_virt_host ();break ;
include/uapi/linux/kvm.h +1 -0
@@ -1135,6 +1135,7 @@ struct kvm_ppc_resize_hpt {#define KVM_CAP_XSAVE2 208#define KVM_CAP_SYS_ATTRIBUTES 209#define KVM_CAP_PPC_AIL_MODE_3 210 +#define KVM_CAP_S390_PROTECTED_ASYNC_DISABLE 215#ifdef KVM_CAP_IRQ_ROUTING
Signature · 1 line
2.34.1
Claudio Imbrenda
maintainerPATCH v8 17/17 KVM: s390: pv: avoid export before import if possible
In reply to Claudio ImbrendaIf the appropriate UV feature bit is set, there is no need to perform an export before import.
--- arch/s390/kernel/uv.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
arch/s390/kernel/uv.c +2 -1
@@ -236,7 +236,8 @@ static int make_secure_pte(pte_t *ptep, unsigned long addr,static bool should_export_before_import (struct uv_cb_header *uvcb,struct mm_struct *mm) { -return uvcb->cmd !=UVC_CMD_UNPIN_PAGE_SHARED && +return !test_bit_inv (BIT_UV_FEAT_MISC , &uv_info.uv_feature_indications) && + uvcb->cmd !=UVC_CMD_UNPIN_PAGE_SHARED &&atomic_read (&mm->context.protected_count) >1 ; }
Signature · 1 line
2.34.1