kexec: extend kexec hypercall for use with pv-ops kernels
Subsystems (2)
v4 cover kexec: extend kexec hypercall for use with pv-ops kernels
The series improves the kexec hypercall by making Xen responsible for loading and relocating the image. This allows kexec to be usable by pv-ops kernels and should allow kexec to be usable from a HVM or PVH privileged domain.
This has now missed the code freeze deadline but could it be considered for 4.3 anyway? kexec isn't a core piece of functionality and I see minimal risk of introducing regressions to Xen as a whole with this series.
The first patch is a simple clean-up.
The second patch allows hypercall structures to be ABI compatible between 32- and 64-bit guests (by reusing stuff present for domctls and sysctls). This seems better than having to keep adding compat handling for new hypercalls etc.
Patch 3 introduces the new ABI.
Patch 4 and 5 nearly completely reimplement the kexec load, unload and exec sub-ops. The old load_v1 sub-op is then implemented on top of the new code.
Patch 6 calls the kexec image when dom0 crashes. This avoids having to alter dom0 kernels to do a exec sub-op call on crash -- a SHUTDOWN_crash by dom0 will trigger the kexec.
Patches 7 and 8 add the libxc API for the kexec calls. These have been acked-by Ian Campbell already.
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/kexec-tools.git;a=summary
Changes since v3:
- Use paddr_t and page_to_maddr() etc. for portability.
- Add explicit padding to hypercall structures where required.
- Minor cleanup of the kexec_reloc assembly.
- Print a message before exec'ing a crash image.
- Style fixes (tabs, trailing whitespace) and typos.
- Fix a bug where using the V1 interface and unloading a image may crash.
Changes since v2:
- Provide old struct xen_kexec_load if __XEN_INTERFACE_VERSION__ < 4.3
- Adjust new struct xen_kexec_load to avoid unnecessary padding.
- Use domheap pages for the image and control pages.
- Remove the DBG() macros from the reloc code.
David
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 1/8 x86: give FIX_EFI_MPF its own fixmap entry
From: David Vrabel <[email protected]>
FIX_EFI_MPF was the same as FIX_KEXEC_BASE_0 which is going away. So add its own entry.
--- xen/arch/x86/mpparse.c | 2 -- xen/include/asm-x86/fixmap.h | 1 + 2 files changed, 1 insertions(+), 2 deletions(-)
xen/arch/x86/mpparse.c +0 -2
@@ -538,8 +538,6 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type) } } -#define FIX_EFI_MPF FIX_KEXEC_BASE_0 -static __init void efi_unmap_mpf (void ) {if (efi_enabled)
xen/include/asm-x86/fixmap.h +1 -0
@@ -71,6 +71,7 @@ enum fixed_addresses {FIX_APEI_RANGE_BASE ,FIX_APEI_RANGE_END =FIX_APEI_RANGE_BASE +FIX_APEI_RANGE_MAX -1 ,FIX_IGD_MMIO , +FIX_EFI_MPF , __end_of_fixed_addresses };
Signature · 1 line
1.7.2.5
PATCH v4 1/8 x86: give FIX_EFI_MPF its own fixmap entry
In reply to David VrabelFrom: David Vrabel <[email protected]>
FIX_EFI_MPF was the same as FIX_KEXEC_BASE_0 which is going away. So add its own entry.
--- xen/arch/x86/mpparse.c | 2 -- xen/include/asm-x86/fixmap.h | 1 + 2 files changed, 1 insertions(+), 2 deletions(-)
xen/arch/x86/mpparse.c +0 -2
@@ -538,8 +538,6 @@ static inline void __init construct_default_ISA_mptable(int mpc_default_type) } } -#define FIX_EFI_MPF FIX_KEXEC_BASE_0 -static __init void efi_unmap_mpf (void ) {if (efi_enabled)
xen/include/asm-x86/fixmap.h +1 -0
@@ -71,6 +71,7 @@ enum fixed_addresses {FIX_APEI_RANGE_BASE ,FIX_APEI_RANGE_END =FIX_APEI_RANGE_BASE +FIX_APEI_RANGE_MAX -1 ,FIX_IGD_MMIO , +FIX_EFI_MPF , __end_of_fixed_addresses };
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 2/8 xen: make GUEST_HANDLE_64() and uint64_aligned_t available everywhere
In reply to David VrabelFrom: David Vrabel <[email protected]>
GUEST_HANDLE_64() and uint64_aligned_t allow hypercall ABI structures to be identical (binary compatible) for 32 and 64-bit guests. They are currently limited to only being available for use in sysctls and domctls. Relax this restriction so they may be used by any new structures.
There is a minimal cost for 32-bit guests on 64-but hypervisors as set_xen_guest_handle() needs to zero the whole field on GUEST_HANDLE_64() handles, but this is expected to be less than the overhead of having to translate compat structures.
--- xen/include/public/arch-x86/xen-x86_32.h | 4 +--- xen/include/public/xen.h | 13 ++++++++----- 2 files changed, 9 insertions(+), 8 deletions(-)
xen/include/public/arch-x86/xen-x86_32.h +1 -3
@@ -91,8 +91,7 @@#define machine_to_phys_mapping ((unsigned long *)MACH2PHYS_VIRT_START)#endif -/* 32-/64-bit invariability for control interfaces (domctl/sysctl). */ -#if defined(__XEN__) || defined(__XEN_TOOLS__) +/* 32-/64-bit invariability. */ #undef ___DEFINE_XEN_GUEST_HANDLE#define ___DEFINE_XEN_GUEST_HANDLE (name, type) \ typedef struct { type *p; } \
@@ -107,7 +106,6 @@#define uint64_aligned_t uint64_t __attribute__((aligned(8)))#define __XEN_GUEST_HANDLE_64 (name) __guest_handle_64_ ## name#define XEN_GUEST_HANDLE_64 (name) __XEN_GUEST_HANDLE_64(name) -#endif #ifndef __ASSEMBLY__
xen/include/public/xen.h +8 -5
@@ -858,9 +858,14 @@ __DEFINE_XEN_GUEST_HANDLE(uint64, uint64_t);#endif /* !__ASSEMBLY__ */ -/* Default definitions for macros used by domctl/sysctl. */ -#if defined(__XEN__) || defined(__XEN_TOOLS__) - +/* +* Default definitions for 32/64-bit invariant macros. +* +* Use these in ABI structures that should be identical for 32 and +* 64-bit guests. There is some (very small) overhead in using +* XEN_GUEST_HANDLE_64() instead of XEN_GUEST_HANDLE() so avoid for +* very hot paths. +*/ #ifndef uint64_aligned_t#define uint64_aligned_t uint64_t#endif
@@ -875,8 +880,6 @@ struct xenctl_cpumap { };#endif -#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ -#endif /* __XEN_PUBLIC_XEN_H__ */ /*
Signature · 1 line
1.7.2.5
PATCH v4 2/8 xen: make GUEST_HANDLE_64() and uint64_aligned_t available everywhere
In reply to David VrabelFrom: David Vrabel <[email protected]>
GUEST_HANDLE_64() and uint64_aligned_t allow hypercall ABI structures to be identical (binary compatible) for 32 and 64-bit guests. They are currently limited to only being available for use in sysctls and domctls. Relax this restriction so they may be used by any new structures.
There is a minimal cost for 32-bit guests on 64-but hypervisors as set_xen_guest_handle() needs to zero the whole field on GUEST_HANDLE_64() handles, but this is expected to be less than the overhead of having to translate compat structures.
--- xen/include/public/arch-x86/xen-x86_32.h | 4 +--- xen/include/public/xen.h | 13 ++++++++----- 2 files changed, 9 insertions(+), 8 deletions(-)
xen/include/public/arch-x86/xen-x86_32.h +1 -3
@@ -91,8 +91,7 @@#define machine_to_phys_mapping ((unsigned long *)MACH2PHYS_VIRT_START)#endif -/* 32-/64-bit invariability for control interfaces (domctl/sysctl). */ -#if defined(__XEN__) || defined(__XEN_TOOLS__) +/* 32-/64-bit invariability. */ #undef ___DEFINE_XEN_GUEST_HANDLE#define ___DEFINE_XEN_GUEST_HANDLE (name, type) \ typedef struct { type *p; } \
@@ -107,7 +106,6 @@#define uint64_aligned_t uint64_t __attribute__((aligned(8)))#define __XEN_GUEST_HANDLE_64 (name) __guest_handle_64_ ## name#define XEN_GUEST_HANDLE_64 (name) __XEN_GUEST_HANDLE_64(name) -#endif #ifndef __ASSEMBLY__
xen/include/public/xen.h +8 -5
@@ -858,9 +858,14 @@ __DEFINE_XEN_GUEST_HANDLE(uint64, uint64_t);#endif /* !__ASSEMBLY__ */ -/* Default definitions for macros used by domctl/sysctl. */ -#if defined(__XEN__) || defined(__XEN_TOOLS__) - +/* +* Default definitions for 32/64-bit invariant macros. +* +* Use these in ABI structures that should be identical for 32 and +* 64-bit guests. There is some (very small) overhead in using +* XEN_GUEST_HANDLE_64() instead of XEN_GUEST_HANDLE() so avoid for +* very hot paths. +*/ #ifndef uint64_aligned_t#define uint64_aligned_t uint64_t#endif
@@ -875,8 +880,6 @@ struct xenctl_cpumap { };#endif -#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ -#endif /* __XEN_PUBLIC_XEN_H__ */ /*
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 3/8 kexec: add public interface for improved load/unload sub-ops
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add replacement KEXEC_CMD_load and KEXEC_CMD_unload sub-ops to the kexec hypercall. These new sub-ops allow a priviledged guest to provide the image data to be loaded into Xen memory or the crash region instead of guests loading the image data themselves and providing the relocation code and metadata.
The old interface is provided to guests requesting an interface version prior to 4.3.
Signed-off: David Vrabel <[email protected]>
--- xen/common/kexec.c | 12 ++++---- xen/include/public/kexec.h | 66 +++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 68 insertions(+), 10 deletions(-)
xen/common/kexec.c +6 -6
@@ -734,7 +734,7 @@ static void crash_save_vmcoreinfo(void)#endif } -static int kexec_load_unload_internal (unsigned long op,xen_kexec_load_t *load) +static int kexec_load_unload_internal (unsigned long op,xen_kexec_load_v1_t *load) {xen_kexec_image_t *image;int base, bit, pos;
@@ -781,7 +781,7 @@ static int kexec_load_unload_internal(unsigned long op, xen_kexec_load_t *load)static int kexec_load_unload (unsigned long op,XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_load_t load; +xen_kexec_load_v1_t load;if (unlikely (copy_from_guest (&load, uarg,1 )) )return -EFAULT ;
@@ -793,8 +793,8 @@ static int kexec_load_unload_compat(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) uarg) {#ifdef CONFIG_COMPAT -compat_kexec_load_t compat_load; -xen_kexec_load_t load; +compat_kexec_load_v1_t compat_load; +xen_kexec_load_v1_t load;if (unlikely (copy_from_guest (&compat_load, uarg,1 )) )return -EFAULT ;
@@ -866,8 +866,8 @@ static int do_kexec_op_internal(unsigned long op,else ret =kexec_get_range (uarg);break ; -case KEXEC_CMD_kexec_load: -case KEXEC_CMD_kexec_unload: +case KEXEC_CMD_kexec_load_v1: +case KEXEC_CMD_kexec_unload_v1:spin_lock_irqsave (&kexec_lock, flags);if (!test_bit (KEXEC_FLAG_IN_PROGRESS , &kexec_flags)) {
xen/include/public/kexec.h +62 -4
80 lines not on this page · raw message
Signature · 1 line
1.7.2.5
PATCH v4 3/8 kexec: add public interface for improved load/unload sub-ops
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add replacement KEXEC_CMD_load and KEXEC_CMD_unload sub-ops to the kexec hypercall. These new sub-ops allow a priviledged guest to provide the image data to be loaded into Xen memory or the crash region instead of guests loading the image data themselves and providing the relocation code and metadata.
The old interface is provided to guests requesting an interface version prior to 4.3.
Signed-off: David Vrabel <[email protected]>
--- xen/common/kexec.c | 12 ++++---- xen/include/public/kexec.h | 66 +++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 68 insertions(+), 10 deletions(-)
xen/common/kexec.c +6 -6
@@ -734,7 +734,7 @@ static void crash_save_vmcoreinfo(void)#endif } -static int kexec_load_unload_internal (unsigned long op,xen_kexec_load_t *load) +static int kexec_load_unload_internal (unsigned long op,xen_kexec_load_v1_t *load) {xen_kexec_image_t *image;int base, bit, pos;
@@ -781,7 +781,7 @@ static int kexec_load_unload_internal(unsigned long op, xen_kexec_load_t *load)static int kexec_load_unload (unsigned long op,XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_load_t load; +xen_kexec_load_v1_t load;if (unlikely (copy_from_guest (&load, uarg,1 )) )return -EFAULT ;
@@ -793,8 +793,8 @@ static int kexec_load_unload_compat(unsigned long op, XEN_GUEST_HANDLE_PARAM(void) uarg) {#ifdef CONFIG_COMPAT -compat_kexec_load_t compat_load; -xen_kexec_load_t load; +compat_kexec_load_v1_t compat_load; +xen_kexec_load_v1_t load;if (unlikely (copy_from_guest (&compat_load, uarg,1 )) )return -EFAULT ;
@@ -866,8 +866,8 @@ static int do_kexec_op_internal(unsigned long op,else ret =kexec_get_range (uarg);break ; -case KEXEC_CMD_kexec_load: -case KEXEC_CMD_kexec_unload: +case KEXEC_CMD_kexec_load_v1: +case KEXEC_CMD_kexec_unload_v1:spin_lock_irqsave (&kexec_lock, flags);if (!test_bit (KEXEC_FLAG_IN_PROGRESS , &kexec_flags)) {
xen/include/public/kexec.h +62 -4
80 lines not on this page · raw message
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 4/8 kexec: add infrastructure for handling kexec images
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add the code needed to handle and load kexec images into Xen memory or into the crash region. This is needed for the new KEXEC_CMD_load and KEXEC_CMD_unload hypercall sub-ops.
Much of this code is derived from the Linux kernel.
--- xen/common/Makefile | 1 + xen/common/kimage.c | 823 ++++++++++++++++++++++++++++++++++++++++++++++ xen/include/xen/kimage.h | 58 ++++ 3 files changed, 882 insertions(+), 0 deletions(-) create mode 100644 xen/common/kimage.c create mode 100644 xen/include/xen/kimage.h
xen/common/Makefile +1 -0
@@ -11,6 +11,7 @@ obj-y += irq.o obj-y += kernel.o obj-y += keyhandler.o obj-$(HAS_KEXEC) += kexec.o +obj-$(HAS_KEXEC) += kimage.o obj-y += lib.o obj-y += memory.o obj-y += multicall.o
xen/common/kimage.c new file +823 -0
823 lines not on this page · raw message
xen/include/xen/kimage.h new file +58 -0
58 lines not on this page · raw message
Signature · 1 line
1.7.2.5
PATCH v4 4/8 kexec: add infrastructure for handling kexec images
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add the code needed to handle and load kexec images into Xen memory or into the crash region. This is needed for the new KEXEC_CMD_load and KEXEC_CMD_unload hypercall sub-ops.
Much of this code is derived from the Linux kernel.
--- xen/common/Makefile | 1 + xen/common/kimage.c | 823 ++++++++++++++++++++++++++++++++++++++++++++++ xen/include/xen/kimage.h | 58 ++++ 3 files changed, 882 insertions(+), 0 deletions(-) create mode 100644 xen/common/kimage.c create mode 100644 xen/include/xen/kimage.h
xen/common/Makefile +1 -0
@@ -11,6 +11,7 @@ obj-y += irq.o obj-y += kernel.o obj-y += keyhandler.o obj-$(HAS_KEXEC) += kexec.o +obj-$(HAS_KEXEC) += kimage.o obj-y += lib.o obj-y += memory.o obj-y += multicall.o
xen/common/kimage.c new file +823 -0
823 lines not on this page · raw message
xen/include/xen/kimage.h new file +58 -0
58 lines not on this page · raw message
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 5/8 kexec: extend hypercall with improved load/unload ops
In reply to David VrabelFrom: David Vrabel <[email protected]>
In the existing kexec hypercall, the load and unload ops depend on internals of the Linux kernel (the page list and code page provided by the kernel). The code page is used to transition between Xen context and the image so using kernel code doesn't make sense and will not work for PVH guests.
Add replacement KEXEC_CMD_kexec_load and KEXEC_CMD_kexec_unload ops that no longer require a code page to be provided by the guest -- Xen now provides the code for calling the image directly.
The new load op looks similar to the Linux kexec_load system call and allows the guest to provide the image data to be loaded. The guest specifies the architecture of the image which may be a 32-bit subarch of the hypervisor's architecture (i.e., an EM_386 image on an EM_X86_64 hypervisor).
The toolstack can now load images without kernel involvement. This is required for supporting kexec when using a dom0 with an upstream kernel.
Crash images are copied directly into the crash region on load. Default images are copied into domheap pages and a list of source and destination machine addresses is created. This is list is used in kexec_reloc() to relocate the image to its destination.
The old load and unload sub-ops are still available (as KEXEC_CMD_load_v1 and KEXEC_CMD_unload_v1) and are implemented on top of the new infrastructure.
--- xen/arch/x86/machine_kexec.c | 282 +++++++++++++++++++------ xen/arch/x86/x86_64/Makefile | 2 +- xen/arch/x86/x86_64/compat_kexec.S | 187 ---------------- xen/arch/x86/x86_64/kexec_reloc.S | 203 ++++++++++++++++++ xen/common/kexec.c | 397 +++++++++++++++++++++++++++++------ xen/common/kimage.c | 103 +++++++++ xen/include/asm-x86/fixmap.h | 3 - xen/include/asm-x86/machine_kexec.h | 14 ++ xen/include/xen/kexec.h | 14 +- xen/include/xen/kimage.h | 6 + 10 files changed, 879 insertions(+), 332 deletions(-) delete mode 100644 xen/arch/x86/x86_64/compat_kexec.S create mode 100644 xen/arch/x86/x86_64/kexec_reloc.S create mode 100644 xen/include/asm-x86/machine_kexec.h
xen/arch/x86/machine_kexec.c +212 -70
@@ -1,9 +1,18 @@/****************************************************************************** * machine_kexec.c * +* Copyright (C) 2013 Citrix Systems R&D Ltd. +* +* Portions derived from Linux's arch/x86/kernel/machine_kexec_64.c. +* +* Copyright (C) 2002-2005 Eric Biederman <[email protected]> +* * Xen port written by: * - Simon 'Horms' Horman <[email protected]> * - Magnus Damm <[email protected]> +* +* This source code is licensed under the GNU General Public License, +* Version 2. See the file COPYING for more details. */ #include <xen/types.h>
@@ -11,63 +20,216 @@#include <xen/guest_access.h> #include <asm/fixmap.h> #include <asm/hpet.h> +#include <asm/page.h> +#include <asm/machine_kexec.h> + +static void init_level2_page (l2_pgentry_t *l2,unsigned long addr) +{ +unsigned long end_addr; + + addr &=PAGE_MASK ; + end_addr = addr +L2_PAGETABLE_ENTRIES * (1ul <<L2_PAGETABLE_SHIFT ); -typedef void (*relocate_new_kernel_t )( -unsigned long indirection_page, -unsigned long *page_list, -unsigned long start_address, -unsigned int preserve_context); +while ( addr < end_addr ) + { +l2e_write (l2++,l2e_from_paddr (addr, __PAGE_HYPERVISOR | _PAGE_PSE)); -int machine_kexec_load (int type,int slot,xen_kexec_image_t *image) + addr +=1ul <<L2_PAGETABLE_SHIFT ; + } +} + +static int init_level3_page (struct kexec_image *image,l3_pgentry_t *l3, +unsigned long addr,unsigned long last_addr) { -unsigned long prev_ma =0 ; -int fix_base =FIX_KEXEC_BASE_0 + (slot * (KEXEC_XEN_NO_PAGES >>1 )); -int k; +unsigned long end_addr; -/* setup fixmap to point to our pages and record the virtual address -* in every odd index in page_list[]. -*/ + addr &=PAGE_MASK ; + end_addr = addr +L3_PAGETABLE_ENTRIES * (1ul <<L3_PAGETABLE_SHIFT ); + +while ( (addr < last_addr) && (addr < end_addr) ) + { +struct page_info *l2_page; +l2_pgentry_t *l2; + + l2_page =kimage_alloc_control_page (image,0 ); +if ( !l2_page ) +return -ENOMEM ; + l2 =__map_domain_page (l2_page); +init_level2_page (l2, addr); +unmap_domain_page (l2); + +l3e_write (l3++,l3e_from_page (l2_page, __PAGE_HYPERVISOR)); + + addr +=1ul <<L3_PAGETABLE_SHIFT ; + } + +return 0 ; +} + +/* +* Build a complete page table to identity map [addr, last_addr). +* +* Control pages are used so they do not overlap with the image source +* or destination. +*/ +static int init_level4_page (struct kexec_image *image,l4_pgentry_t *l4, +unsigned long addr,unsigned long last_addr) +{ +unsigned long end_addr; +int result; + + addr &=PAGE_MASK ; + end_addr = addr +L4_PAGETABLE_ENTRIES * (1ul <<L4_PAGETABLE_SHIFT ); + +while ( (addr < last_addr) && (addr < end_addr) ) + { +struct page_info *l3_page; +l3_pgentry_t *l3; + + l3_page =kimage_alloc_control_page (image,0 ); +if ( !l3_page ) +return -ENOMEM ; + l3 =__map_domain_page (l3_page); + result =init_level3_page (image, l3, addr, last_addr); +unmap_domain_page (l3); +if (result) +return result; + +l4e_write (l4++,l4e_from_page (l3_page, __PAGE_HYPERVISOR)); + + addr +=1ul <<L4_PAGETABLE_SHIFT ; + } + +return 0 ; +} + +/* +* Add a mapping for the control code page to the same virtual address +* as kexec_reloc. This allows us to keep running after these page +* tables are loaded in kexec_reloc. +* +* We don't really need to allocate control pages here as these +* entries won't be used while the kexec image is being copied, but it +* makes clean-up easier. +*/ +static int init_transition_pgtable (struct kexec_image *image,l4_pgentry_t *l4) +{ +struct page_info *l3_page; +struct page_info *l2_page; +struct page_info *l1_page; +unsigned long vaddr, paddr; +l3_pgentry_t *l3 =NULL ; +l2_pgentry_t *l2 =NULL ; +l1_pgentry_t *l1 =NULL ; +int ret = -ENOMEM ; + + vaddr = (unsigned long )kexec_reloc; + paddr =page_to_maddr (image->control_code_page); + + l4 +=l4_table_offset (vaddr); +if ( !(l4e_get_flags (*l4) & _PAGE_PRESENT) ) + { + l3_page =kimage_alloc_control_page (image,0 ); +if ( !l3_page ) + goto out; +l4e_write (l4,l4e_from_page (l3_page, __PAGE_HYPERVISOR)); + } +else + l3_page =l4e_get_page (*l4); + + l3 =__map_domain_page (l3_page); + l3 +=l3_table_offset (vaddr); +if ( !(l3e_get_flags (*l3) & _PAGE_PRESENT) ) + { + l2_page =kimage_alloc_control_page (image,0 ); +if ( !l2_page ) + goto out; +l3e_write (l3,l3e_from_page (l2_page, __PAGE_HYPERVISOR)); + } +else + l2_page =l3e_get_page (*l3); + + l2 =__map_domain_page (l2_page); + l2 +=l2_table_offset (vaddr); +if ( !(l2e_get_flags (*l2) & _PAGE_PRESENT) ) + { + l1_page =kimage_alloc_control_page (image,0 ); +if ( !l1_page ) + goto out; +l2e_write (l2,l2e_from_page (l1_page, __PAGE_HYPERVISOR)); + } +else + l1_page =l2e_get_page (*l2); + + l1 =__map_domain_page (l1_page); + l1 +=l1_table_offset (vaddr); +l1e_write (l1,l1e_from_pfn (paddr >>PAGE_SHIFT , __PAGE_HYPERVISOR)); + + ret =0 ; +out: +if ( l1 ) +unmap_domain_page (l1); +if ( l2 ) +unmap_domain_page (l2); +if ( l3 ) +unmap_domain_page (l3); +return ret; +} -for ( k =0 ; k <KEXEC_XEN_NO_PAGES ; k++ ) + +static int build_reloc_page_table (struct kexec_image *image) +{ +struct page_info *l4_page; +l4_pgentry_t *l4; +int result; + + l4_page =kimage_alloc_control_page (image,0 ); +if ( !l4_page ) +return -ENOMEM ; + l4 =__map_domain_page (l4_page); + + result =init_level4_page (image, l4,0 , max_page <<PAGE_SHIFT ); +if ( result ==0 ) + result =init_transition_pgtable (image, l4); +unmap_domain_page (l4); +if ( result ) +return result; + + image->aux_page = l4_page; +return 0 ; +} + +int machine_kexec_load (struct kexec_image *image) +{ +void *code_page; +int ret; + +switch ( image->arch ) { -if ( (k &1 ) ==0 ) - { -/* Even pages: machine address. */ - prev_ma = image->page_list[k]; - } -else - { -/* Odd pages: va for previous ma. */ -if (is_pv_32on64_domain (dom0) ) - { -/* -* The compatability bounce code sets up a page table -* with a 1-1 mapping of the first 1G of memory so -* VA==PA here. -* -* This Linux purgatory code still sets up separate -* high and low mappings on the control page (entries -* 0 and 1) but it is harmless if they are equal since -* that PT is not live at the time. -*/ - image->page_list[k] = prev_ma; - } -else - { -set_fixmap (fix_base + (k >>1 ), prev_ma); - image->page_list[k] =fix_to_virt (fix_base + (k >>1 )); - } - } +case EM_386 : +case EM_X86_64 : +break ; +default : +return -EINVAL ; } + code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE ); +unmap_domain_page (code_page); + + ret =build_reloc_page_table (image); +if ( ret <0 ) +return ret; +return 0 ; } -void machine_kexec_unload (int type,int slot,xen_kexec_image_t *image) +void machine_kexec_unload (struct kexec_image *image) { +/* no-op. kimage_free() frees all control pages. */ } -void machine_reboot_kexec (xen_kexec_image_t *image) +void machine_reboot_kexec (struct kexec_image *image) {BUG_ON (smp_processor_id () !=0 );smp_send_stop ();
@@ -75,13 +237,10 @@ void machine_reboot_kexec(xen_kexec_image_t *image)BUG (); } -void machine_kexec (xen_kexec_image_t *image) +void machine_kexec (struct kexec_image *image) { -struct desc_ptr gdt_desc = { - .base = (unsigned long )(boot_cpu_gdt_table -FIRST_RESERVED_GDT_ENTRY ), - .limit =LAST_RESERVED_GDT_BYTE - };int i; +unsigned long reloc_flags =0 ;/* We are about to permenantly jump out of the Xen context into the kexec * purgatory code. We really dont want to be still servicing interupts.
@@ -109,29 +268,12 @@ void machine_kexec(xen_kexec_image_t *image)* not like running with NMIs disabled. */ enable_nmis (); -/* -* compat_machine_kexec() returns to idle pagetables, which requires us -* to be running on a static GDT mapping (idle pagetables have no GDT -* mappings in their per-domain mapping area). -*/ - asmvolatile ("lgdt %0" : :"m" (gdt_desc) ); +if ( image->arch ==EM_386 ) + reloc_flags |=KEXEC_RELOC_FLAG_COMPAT ; -if (is_pv_32on64_domain (dom0) ) - { -compat_machine_kexec (image->page_list[1 ], - image->indirection_page, - image->page_list, - image->start_address); - } -else - { -relocate_new_kernel_t rnk; - - rnk = (relocate_new_kernel_t ) image->page_list[1 ]; - (*rnk)(image->indirection_page, image->page_list, - image->start_address, -0 /* preserve_context */ ); - } +kexec_reloc (page_to_maddr (image->control_code_page), +page_to_maddr (image->aux_page), + image->head, image->entry_maddr, reloc_flags); }int machine_kexec_get (xen_kexec_range_t *range)
xen/arch/x86/x86_64/Makefile +1 -1
@@ -11,11 +11,11 @@ obj-y += mmconf-fam10h.o obj-y += mmconfig_64.o obj-y += mmconfig-shared.o obj-y += compat.o -obj-bin-y += compat_kexec.o obj-y += domain.o obj-y += physdev.o obj-y += platform_hypercall.o obj-y += cpu_idle.o obj-y += cpufreq.o +obj-bin-y += kexec_reloc.o obj-$(crash_debug) += gdbstub.o
xen/arch/x86/x86_64/compat_kexec.S deleted +0 -187
187 lines not on this page · raw message
xen/arch/x86/x86_64/kexec_reloc.S new file +203 -0
203 lines not on this page · raw message
xen/common/kexec.c +335 -62
494 lines not on this page · raw message
xen/common/kimage.c +103 -0
109 lines not on this page · raw message
xen/include/asm-x86/fixmap.h +0 -3
@@ -57,9 +57,6 @@ enum fixed_addresses {FIX_ACPI_END =FIX_ACPI_BEGIN +FIX_ACPI_PAGES -1 ,FIX_HPET_BASE ,FIX_CYCLONE_TIMER , -FIX_KEXEC_BASE_0 , -FIX_KEXEC_BASE_END =FIX_KEXEC_BASE_0 \ - + ((KEXEC_XEN_NO_PAGES >>1 ) *KEXEC_IMAGE_NR ) -1 ,FIX_IOMMU_REGS_BASE_0 ,FIX_IOMMU_REGS_END =FIX_IOMMU_REGS_BASE_0 +MAX_IOMMUS -1 , FIX_IOMMU_MMIO_BASE_0,
xen/include/asm-x86/machine_kexec.h new file +14 -0
@@ -0,0 +1,14 @@ +#ifndef __X86_MACHINE_KEXEC_H__ +#define __X86_MACHINE_KEXEC_H__ + +#define KEXEC_RELOC_FLAG_COMPAT 0x1/* 32-bit image */ + +#ifndef __ASSEMBLY__ + +extern void kexec_reloc (unsigned long reloc_code,unsigned long reloc_pt, +unsigned long ind_maddr,unsigned long entry_maddr, +unsigned long flags); + +#endif + +#endif /* __X86_MACHINE_KEXEC_H__ */
xen/include/xen/kexec.h +5 -9
@@ -6,6 +6,7 @@#include <public/kexec.h> #include <asm/percpu.h> #include <xen/elfcore.h> +#include <xen/kimage.h> typedef struct xen_kexec_reserve { unsigned long size;
@@ -40,11 +41,11 @@ extern enum low_crashinfo low_crashinfo_mode;extern paddr_t crashinfo_maxaddr_bits;void kexec_early_calculations (void ); -int machine_kexec_load (int type,int slot,xen_kexec_image_t *image); -void machine_kexec_unload (int type,int slot,xen_kexec_image_t *image); +int machine_kexec_load (struct kexec_image *image); +void machine_kexec_unload (struct kexec_image *image);void machine_kexec_reserved (xen_kexec_reserve_t *reservation); -void machine_reboot_kexec (xen_kexec_image_t *image); -void machine_kexec (xen_kexec_image_t *image); +void machine_reboot_kexec (struct kexec_image *image); +void machine_kexec (struct kexec_image *image);void kexec_crash (void );void kexec_crash_save_cpu (void );crash_xen_info_t *kexec_crash_save_info (void );
@@ -52,11 +53,6 @@ void machine_crash_shutdown(void);int machine_kexec_get (xen_kexec_range_t *range);int machine_kexec_get_xen (xen_kexec_range_t *range); -void compat_machine_kexec (unsigned long rnk, -unsigned long indirection_page, -unsigned long *page_list, -unsigned long start_address); -/* vmcoreinfo stuff */ #define VMCOREINFO_BYTES (4096)#define VMCOREINFO_NOTE_NAME "VMCOREINFO_XEN"
xen/include/xen/kimage.h +6 -0
@@ -45,6 +45,12 @@ int kimage_load_segments(struct kexec_image *image);struct page_info *kimage_alloc_control_page (struct kexec_image *image,unsigned memflags); +kimage_entry_t *kimage_entry_next (kimage_entry_t *entry,bool_t compat); +unsigned long kimage_entry_mfn (kimage_entry_t *entry,bool_t compat); +unsigned long kimage_entry_ind (kimage_entry_t *entry,bool_t compat); +int kimage_build_ind (struct kexec_image *image,unsigned long ind_mfn, +bool_t compat); +#endif /* __XEN_KIMAGE_H__ */ /*
Signature · 1 line
1.7.2.5
Re: [Xen-devel] [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
Quoted 9 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +3
-4-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments;
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 10 lines
xen/common/kexec.c +4
-2+struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ; -if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;
Especially since you named the padding field _rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it _pad instead.
Jan
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
Quoted 16 lines · Jan Beulich
Quoted 16 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +6
-5-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments; +struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ;
Quoted 8 lines
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 3 lines
xen/common/kexec.c +1
-1-if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;Especially since you named the padding field
_rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it_padinstead.
8 bits isn't likely to be useful and the interface can always be extended by adding a new sub-ob. I'll rename it to _pad.
Do you want to put your acked-by on this patch (with this change) or on any of the other patches?
David
Re: [Xen-devel] [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to Jan BeulichQuoted 16 lines · Jan Beulich
Quoted 16 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +6
-5-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments; +struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ;
Quoted 8 lines
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 3 lines
xen/common/kexec.c +1
-1-if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;Especially since you named the padding field
_rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it_padinstead.
8 bits isn't likely to be useful and the interface can always be extended by adding a new sub-ob. I'll rename it to _pad.
Do you want to put your acked-by on this patch (with this change) or on any of the other patches?
David
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Re: [Xen-devel] [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
Quoted 27 lines
Quoted 1 line
Quoted 1 line · David Vrabel
Quoted 16 lines · Jan Beulich
Quoted 16 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +6
-5-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments; +struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ;Quoted 8 lines
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 3 lines
xen/common/kexec.c +1
-1-if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;Especially since you named the padding field
_rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it_padinstead.
Quoted 5 lines
8 bits isn't likely to be useful and the interface can always be extended by adding a new sub-ob. I'll rename it to
_pad.Do you want to put your acked-by on this patch (with this change) or on any of the other patches?
No, I didn't look at this closely enough to do so.
Jan
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to David VrabelQuoted 27 lines
Quoted 1 line
Quoted 1 line · David Vrabel
Quoted 16 lines · Jan Beulich
Quoted 16 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +6
-5-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments; +struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ;Quoted 8 lines
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 3 lines
xen/common/kexec.c +1
-1-if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;Especially since you named the padding field
_rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it_padinstead.
Quoted 5 lines
8 bits isn't likely to be useful and the interface can always be extended by adding a new sub-ob. I'll rename it to
_pad.Do you want to put your acked-by on this patch (with this change) or on any of the other patches?
No, I didn't look at this closely enough to do so.
Jan
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to David VrabelQuoted 9 lines
Quoted 1 line
Quoted 1 line · David Vrabel
xen/common/kexec.c +3
-4-static int kexec_exec (XEN_GUEST_HANDLE_PARAM (void ) uarg) +static int kexec_load (XEN_GUEST_HANDLE_PARAM (void ) uarg) { -xen_kexec_exec_t exec; -xen_kexec_image_t *image; -int base, bit, pos, ret = -EINVAL ; +xen_kexec_load_t load; +xen_kexec_segment_t *segments;
xen/common/kexec.c static int kexec_load_unload_compat(unsigned long op, · line 1032
Quoted 10 lines
xen/common/kexec.c +4
-2+struct kexec_image *kimage =NULL ; +int ret; -if (unlikely (copy_from_guest (&exec, uarg,1 )) ) +if (copy_from_guest (&load, uarg,1 ) )return -EFAULT ; -if (kexec_load_get_bits (exec.type, &base, &bit) ) +if ( load.nr_segments >=KEXEC_SEGMENT_MAX )return -EINVAL ;
Especially since you named the padding field _rsvd, you ought to verify it to be zero somewhere here. Or if you're really sure that nobody will ever want to make use of the field, name it _pad instead.
Jan
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to David VrabelQuoted 32 lines · David Vrabel
From: David Vrabel <[email protected]>
In the existing kexec hypercall, the load and unload ops depend on internals of the Linux kernel (the page list and code page provided by the kernel). The code page is used to transition between Xen context and the image so using kernel code doesn't make sense and will not work for PVH guests.
Add replacement
KEXEC_CMD_kexec_loadandKEXEC_CMD_kexec_unloadops that no longer require a code page to be provided by the guest -- Xen now provides the code for calling the image directly.The new load op looks similar to the Linux
kexec_loadsystem call and allows the guest to provide the image data to be loaded. The guest specifies the architecture of the image which may be a 32-bit subarch of the hypervisor's architecture (i.e., anEM_386image on anEM_X86_64hypervisor).The toolstack can now load images without kernel involvement. This is required for supporting kexec when using a dom0 with an upstream kernel.
Crash images are copied directly into the crash region on load. Default images are copied into domheap pages and a list of source and destination machine addresses is created. This is list is used in
kexec_reloc()to relocate the image to its destination.The old load and unload sub-ops are still available (as
KEXEC_CMD_load_v1andKEXEC_CMD_unload_v1) and are implemented on top of the new infrastructure.Signed-off-by David Vrabel <[email protected]>
[...]
Quoted 34 lines
xen/arch/x86/machine_kexec.c +6
-27+int machine_kexec_load (struct kexec_image *image) +{ +void *code_page; +int ret; + +switch ( image->arch ) { -if ( (k &1 ) ==0 ) - { -/* Even pages: machine address. */ - prev_ma = image->page_list[k]; - } -else - { -/* Odd pages: va for previous ma. */ -if (is_pv_32on64_domain (dom0) ) - { -/* -* The compatability bounce code sets up a page table -* with a 1-1 mapping of the first 1G of memory so -* VA==PA here. -* -* This Linux purgatory code still sets up separate -* high and low mappings on the control page (entries -* 0 and 1) but it is harmless if they are equal since -* that PT is not live at the time. -*/ - image->page_list[k] = prev_ma; - } -else - { -set_fixmap (fix_base + (k >>1 ), prev_ma); - image->page_list[k] =fix_to_virt (fix_base + (k >>1 )); - }
xen/arch/x86/machine_kexec.c line 217
Quoted 10 lines
xen/arch/x86/machine_kexec.c +7
-1- } +case EM_386 : +case EM_X86_64 : +break ; +default : +return -EINVAL ; } + code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
Daniel
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to David VrabelQuoted 32 lines · David Vrabel
From: David Vrabel <[email protected]>
In the existing kexec hypercall, the load and unload ops depend on internals of the Linux kernel (the page list and code page provided by the kernel). The code page is used to transition between Xen context and the image so using kernel code doesn't make sense and will not work for PVH guests.
Add replacement
KEXEC_CMD_kexec_loadandKEXEC_CMD_kexec_unloadops that no longer require a code page to be provided by the guest -- Xen now provides the code for calling the image directly.The new load op looks similar to the Linux
kexec_loadsystem call and allows the guest to provide the image data to be loaded. The guest specifies the architecture of the image which may be a 32-bit subarch of the hypervisor's architecture (i.e., anEM_386image on anEM_X86_64hypervisor).The toolstack can now load images without kernel involvement. This is required for supporting kexec when using a dom0 with an upstream kernel.
Crash images are copied directly into the crash region on load. Default images are copied into domheap pages and a list of source and destination machine addresses is created. This is list is used in
kexec_reloc()to relocate the image to its destination.The old load and unload sub-ops are still available (as
KEXEC_CMD_load_v1andKEXEC_CMD_unload_v1) and are implemented on top of the new infrastructure.Signed-off-by David Vrabel <[email protected]>
[...]
Quoted 34 lines
xen/arch/x86/machine_kexec.c +6
-27+int machine_kexec_load (struct kexec_image *image) +{ +void *code_page; +int ret; + +switch ( image->arch ) { -if ( (k &1 ) ==0 ) - { -/* Even pages: machine address. */ - prev_ma = image->page_list[k]; - } -else - { -/* Odd pages: va for previous ma. */ -if (is_pv_32on64_domain (dom0) ) - { -/* -* The compatability bounce code sets up a page table -* with a 1-1 mapping of the first 1G of memory so -* VA==PA here. -* -* This Linux purgatory code still sets up separate -* high and low mappings on the control page (entries -* 0 and 1) but it is harmless if they are equal since -* that PT is not live at the time. -*/ - image->page_list[k] = prev_ma; - } -else - { -set_fixmap (fix_base + (k >>1 ), prev_ma); - image->page_list[k] =fix_to_virt (fix_base + (k >>1 )); - }
xen/arch/x86/machine_kexec.c line 217
Quoted 10 lines
xen/arch/x86/machine_kexec.c +7
-1- } +case EM_386 : +case EM_X86_64 : +break ; +default : +return -EINVAL ; } + code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
Daniel
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
Quoted 8 lines · Daniel Kiper
xen/arch/x86/machine_kexec.c line 217
Quoted 5 lines · David Vrabel
}xen/arch/x86/machine_kexec.c +2
-0+ code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
kexec_reloc_size is absolute symbol and doing this give linker errors. FWIW, Linux also uses a #define'd value for its similar memcpy.
I have added a link time check that kexec_reloc_size <= PAGE_SIZE.
David
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to Daniel KiperQuoted 8 lines · Daniel Kiper
xen/arch/x86/machine_kexec.c line 217
Quoted 5 lines · David Vrabel
}xen/arch/x86/machine_kexec.c +2
-0+ code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
kexec_reloc_size is absolute symbol and doing this give linker errors. FWIW, Linux also uses a #define'd value for its similar memcpy.
I have added a link time check that kexec_reloc_size <= PAGE_SIZE.
David
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
Quoted 11 lines · David Vrabel
Quoted 8 lines · Daniel Kiper
xen/arch/x86/machine_kexec.c line 217
Quoted 5 lines · David Vrabel
}xen/arch/x86/machine_kexec.c +2
-0+ code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
kexec_reloc_sizeis absolute symbol and doing this give linker errors.
Yes, it should be changed to something like that:
kexec_reloc_size:
.long . - xen_relocate_kernel
Somwhere in xen/include/asm-x86/machine_kexec.h:
extern unsigned int kexec_reloc_size;
Quoted 1 line
FWIW, Linux also uses a #define'd value for its similar memcpy.
I saw that sometime ago and I think this is a bug. We should copy only kexec_reloc() code and nothing else. Otherwise we ask for problems.
I am going to post relevant patches for this and others kexec issues found in Linux Kernel.
Quoted 1 line
I have added a link time check that
kexec_reloc_size<=PAGE_SIZE.
Good idea but it should be kexec_reloc_size <= KEXEC_CONTROL_PAGE_SIZE.
Daniel
Re: [PATCH 5/8] kexec: extend hypercall with improved load/unload ops
In reply to David VrabelQuoted 11 lines · David Vrabel
Quoted 8 lines · Daniel Kiper
xen/arch/x86/machine_kexec.c line 217
Quoted 5 lines · David Vrabel
}xen/arch/x86/machine_kexec.c +2
-0+ code_page =__map_domain_page (image->control_code_page); +memcpy (code_page, kexec_reloc,PAGE_SIZE );
memcpy(code_page, kexec_reloc, kexec_reloc_size);
kexec_reloc_sizeis absolute symbol and doing this give linker errors.
Yes, it should be changed to something like that:
kexec_reloc_size:
.long . - xen_relocate_kernel
Somwhere in xen/include/asm-x86/machine_kexec.h:
extern unsigned int kexec_reloc_size;
Quoted 1 line
FWIW, Linux also uses a #define'd value for its similar memcpy.
I saw that sometime ago and I think this is a bug. We should copy only kexec_reloc() code and nothing else. Otherwise we ask for problems.
I am going to post relevant patches for this and others kexec issues found in Linux Kernel.
Quoted 1 line
I have added a link time check that
kexec_reloc_size<=PAGE_SIZE.
Good idea but it should be kexec_reloc_size <= KEXEC_CONTROL_PAGE_SIZE.
Daniel
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 6/8 xen: kexec crash image when dom0 crashes
In reply to David VrabelFrom: David Vrabel <[email protected]>
--- xen/common/kexec.c | 2 ++ xen/common/shutdown.c | 3 +++ 2 files changed, 5 insertions(+), 0 deletions(-)
xen/common/kexec.c +2 -0
@@ -307,6 +307,8 @@ void kexec_crash(void)if ( !test_bit (KEXEC_IMAGE_CRASH_BASE + pos, &kexec_flags) )return ; +printk ("Executing crash image\n" ); + kexecing = TRUE;kexec_common_shutdown ();
xen/common/shutdown.c +3 -0
@@ -47,6 +47,9 @@ void dom0_shutdown(u8 reason) {debugger_trap_immediate ();printk ("Domain 0 crashed: " ); +#ifdef CONFIG_KEXEC +kexec_crash (); +#endif maybe_reboot ();break ;/* not reached */ }
Signature · 1 line
1.7.2.5
PATCH v4 6/8 xen: kexec crash image when dom0 crashes
In reply to David VrabelFrom: David Vrabel <[email protected]>
--- xen/common/kexec.c | 2 ++ xen/common/shutdown.c | 3 +++ 2 files changed, 5 insertions(+), 0 deletions(-)
xen/common/kexec.c +2 -0
@@ -307,6 +307,8 @@ void kexec_crash(void)if ( !test_bit (KEXEC_IMAGE_CRASH_BASE + pos, &kexec_flags) )return ; +printk ("Executing crash image\n" ); + kexecing = TRUE;kexec_common_shutdown ();
xen/common/shutdown.c +3 -0
@@ -47,6 +47,9 @@ void dom0_shutdown(u8 reason) {debugger_trap_immediate ();printk ("Domain 0 crashed: " ); +#ifdef CONFIG_KEXEC +kexec_crash (); +#endif maybe_reboot ();break ;/* not reached */ }
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 7/8 libxc: add hypercall buffer arrays
In reply to David VrabelFrom: David Vrabel <[email protected]>
Hypercall buffer arrays are used when a hypercall takes a variable length array of buffers.
--- tools/libxc/xc_hcall_buf.c | 73 ++++++++++++++++++++++++++++++++++++++++++++ tools/libxc/xenctrl.h | 27 ++++++++++++++++ 2 files changed, 100 insertions(+), 0 deletions(-)
tools/libxc/xc_hcall_buf.c +73 -0
@@ -228,6 +228,79 @@ void xc__hypercall_bounce_post(xc_interface *xch, xc_hypercall_buffer_t *b)xc__hypercall_buffer_free (xch, b); } +struct xc_hypercall_buffer_array { +unsigned max_bufs; +xc_hypercall_buffer_t *bufs; +}; + +xc_hypercall_buffer_array_t *xc_hypercall_buffer_array_create (xc_interface *xch, +unsigned n) +{ +xc_hypercall_buffer_array_t *array; +xc_hypercall_buffer_t *bufs =NULL ; + + array =malloc (sizeof (*array)); +if ( array ==NULL ) + goto error; + + bufs =calloc (n,sizeof (*bufs)); +if ( bufs ==NULL ) + goto error; + + array->max_bufs = n; + array->bufs = bufs; + +return array; + +error: +free (bufs); +free (array); +return NULL ; +} + +void *xc__hypercall_buffer_array_alloc (xc_interface *xch, +xc_hypercall_buffer_array_t *array, +unsigned index, +xc_hypercall_buffer_t *hbuf, +size_t size) +{ +void *buf; + +if ( index >= array->max_bufs || array->bufs[index].hbuf ) +abort (); + + buf =xc__hypercall_buffer_alloc (xch, hbuf, size); +if ( buf ) + array->bufs[index] = *hbuf; +return buf; +} + +void *xc__hypercall_buffer_array_get (xc_interface *xch, +xc_hypercall_buffer_array_t *array, +unsigned index, +xc_hypercall_buffer_t *hbuf) +{ +if ( index >= array->max_bufs || array->bufs[index].hbuf ==NULL ) +abort (); + + *hbuf = array->bufs[index]; +return array->bufs[index].hbuf; +} + +void xc_hypercall_buffer_array_destroy (xc_interface *xc, +xc_hypercall_buffer_array_t *array) +{ +unsigned i; + +if ( array ==NULL ) +return ; + +for (i =0 ; i < array->max_bufs; i++ ) +xc__hypercall_buffer_free (xc, &array->bufs[i]); +free (array->bufs); +free (array); +} +/* * Local variables: * mode: C
tools/libxc/xenctrl.h +27 -0
@@ -321,6 +321,33 @@ void xc__hypercall_buffer_free_pages(xc_interface *xch, xc_hypercall_buffer_t *b#define xc_hypercall_buffer_free_pages (_xch, _name, _nr) xc__hypercall_buffer_free_pages(_xch, HYPERCALL_BUFFER(_name), _nr)/* +* Array of hypercall buffers. +* +* Create an array with xc_hypercall_buffer_array_create() and +* populate it by declaring one hypercall buffer in a loop and +* allocating the buffer with xc_hypercall_buffer_array_alloc(). +* +* To access a previously allocated buffers, declare a new hypercall +* buffer and call xc_hypercall_buffer_array_get(). +* +* Destroy the array with xc_hypercall_buffer_array_destroy() to free +* the array and all its alocated hypercall buffers. +*/ +struct xc_hypercall_buffer_array ; +typedef struct xc_hypercall_buffer_array xc_hypercall_buffer_array_t ; + +xc_hypercall_buffer_array_t *xc_hypercall_buffer_array_create (xc_interface *xch,unsigned n); +void *xc__hypercall_buffer_array_alloc (xc_interface *xch,xc_hypercall_buffer_array_t *array, +unsigned index,xc_hypercall_buffer_t *hbuf,size_t size); +#define xc_hypercall_buffer_array_alloc (_xch, _array, _index, _name, _size) \ + xc__hypercall_buffer_array_alloc(_xch, _array, _index, HYPERCALL_BUFFER(_name), _size) +void *xc__hypercall_buffer_array_get (xc_interface *xch,xc_hypercall_buffer_array_t *array, +unsigned index,xc_hypercall_buffer_t *hbuf); +#define xc_hypercall_buffer_array_get (_xch, _array, _index, _name, _size) \ + xc__hypercall_buffer_array_get(_xch, _array, _index, HYPERCALL_BUFFER(_name)) +void xc_hypercall_buffer_array_destroy (xc_interface *xc,xc_hypercall_buffer_array_t *array); + +/* * CPUMAP handling */ typedef uint8_t *xc_cpumap_t ;
Signature · 1 line
1.7.2.5
PATCH v4 7/8 libxc: add hypercall buffer arrays
In reply to David VrabelFrom: David Vrabel <[email protected]>
Hypercall buffer arrays are used when a hypercall takes a variable length array of buffers.
--- tools/libxc/xc_hcall_buf.c | 73 ++++++++++++++++++++++++++++++++++++++++++++ tools/libxc/xenctrl.h | 27 ++++++++++++++++ 2 files changed, 100 insertions(+), 0 deletions(-)
tools/libxc/xc_hcall_buf.c +73 -0
@@ -228,6 +228,79 @@ void xc__hypercall_bounce_post(xc_interface *xch, xc_hypercall_buffer_t *b)xc__hypercall_buffer_free (xch, b); } +struct xc_hypercall_buffer_array { +unsigned max_bufs; +xc_hypercall_buffer_t *bufs; +}; + +xc_hypercall_buffer_array_t *xc_hypercall_buffer_array_create (xc_interface *xch, +unsigned n) +{ +xc_hypercall_buffer_array_t *array; +xc_hypercall_buffer_t *bufs =NULL ; + + array =malloc (sizeof (*array)); +if ( array ==NULL ) + goto error; + + bufs =calloc (n,sizeof (*bufs)); +if ( bufs ==NULL ) + goto error; + + array->max_bufs = n; + array->bufs = bufs; + +return array; + +error: +free (bufs); +free (array); +return NULL ; +} + +void *xc__hypercall_buffer_array_alloc (xc_interface *xch, +xc_hypercall_buffer_array_t *array, +unsigned index, +xc_hypercall_buffer_t *hbuf, +size_t size) +{ +void *buf; + +if ( index >= array->max_bufs || array->bufs[index].hbuf ) +abort (); + + buf =xc__hypercall_buffer_alloc (xch, hbuf, size); +if ( buf ) + array->bufs[index] = *hbuf; +return buf; +} + +void *xc__hypercall_buffer_array_get (xc_interface *xch, +xc_hypercall_buffer_array_t *array, +unsigned index, +xc_hypercall_buffer_t *hbuf) +{ +if ( index >= array->max_bufs || array->bufs[index].hbuf ==NULL ) +abort (); + + *hbuf = array->bufs[index]; +return array->bufs[index].hbuf; +} + +void xc_hypercall_buffer_array_destroy (xc_interface *xc, +xc_hypercall_buffer_array_t *array) +{ +unsigned i; + +if ( array ==NULL ) +return ; + +for (i =0 ; i < array->max_bufs; i++ ) +xc__hypercall_buffer_free (xc, &array->bufs[i]); +free (array->bufs); +free (array); +} +/* * Local variables: * mode: C
tools/libxc/xenctrl.h +27 -0
@@ -321,6 +321,33 @@ void xc__hypercall_buffer_free_pages(xc_interface *xch, xc_hypercall_buffer_t *b#define xc_hypercall_buffer_free_pages (_xch, _name, _nr) xc__hypercall_buffer_free_pages(_xch, HYPERCALL_BUFFER(_name), _nr)/* +* Array of hypercall buffers. +* +* Create an array with xc_hypercall_buffer_array_create() and +* populate it by declaring one hypercall buffer in a loop and +* allocating the buffer with xc_hypercall_buffer_array_alloc(). +* +* To access a previously allocated buffers, declare a new hypercall +* buffer and call xc_hypercall_buffer_array_get(). +* +* Destroy the array with xc_hypercall_buffer_array_destroy() to free +* the array and all its alocated hypercall buffers. +*/ +struct xc_hypercall_buffer_array ; +typedef struct xc_hypercall_buffer_array xc_hypercall_buffer_array_t ; + +xc_hypercall_buffer_array_t *xc_hypercall_buffer_array_create (xc_interface *xch,unsigned n); +void *xc__hypercall_buffer_array_alloc (xc_interface *xch,xc_hypercall_buffer_array_t *array, +unsigned index,xc_hypercall_buffer_t *hbuf,size_t size); +#define xc_hypercall_buffer_array_alloc (_xch, _array, _index, _name, _size) \ + xc__hypercall_buffer_array_alloc(_xch, _array, _index, HYPERCALL_BUFFER(_name), _size) +void *xc__hypercall_buffer_array_get (xc_interface *xch,xc_hypercall_buffer_array_t *array, +unsigned index,xc_hypercall_buffer_t *hbuf); +#define xc_hypercall_buffer_array_get (_xch, _array, _index, _name, _size) \ + xc__hypercall_buffer_array_get(_xch, _array, _index, HYPERCALL_BUFFER(_name)) +void xc_hypercall_buffer_array_destroy (xc_interface *xc,xc_hypercall_buffer_array_t *array); + +/* * CPUMAP handling */ typedef uint8_t *xc_cpumap_t ;
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 8/8 libxc: add API for kexec hypercall
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add xc_kexec_exec(), xc_kexec_get_ranges(), xc_kexec_load(), and xc_kexec_unload(). The load and unload calls require the v2 load and unload ops.
--- tools/libxc/Makefile | 1 + tools/libxc/xc_kexec.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++++ tools/libxc/xenctrl.h | 55 +++++++++++++++++++ 3 files changed, 196 insertions(+), 0 deletions(-) create mode 100644 tools/libxc/xc_kexec.c
tools/libxc/Makefile +1 -0
@@ -31,6 +31,7 @@ CTRL_SRCS-y += xc_mem_access.c CTRL_SRCS-y += xc_memshr.c CTRL_SRCS-y += xc_hcall_buf.c CTRL_SRCS-y += xc_foreign_memory.c +CTRL_SRCS-y += xc_kexec.c CTRL_SRCS-y += xtl_core.c CTRL_SRCS-y += xtl_logger_stdio.c CTRL_SRCS-$(CONFIG_X86) += xc_pagetab.c
tools/libxc/xc_kexec.c new file +140 -0
140 lines not on this page · raw message
tools/libxc/xenctrl.h +55 -0
65 lines not on this page · raw message
Signature · 1 line
1.7.2.5
PATCH v4 8/8 libxc: add API for kexec hypercall
In reply to David VrabelFrom: David Vrabel <[email protected]>
Add xc_kexec_exec(), xc_kexec_get_ranges(), xc_kexec_load(), and xc_kexec_unload(). The load and unload calls require the v2 load and unload ops.
--- tools/libxc/Makefile | 1 + tools/libxc/xc_kexec.c | 140 ++++++++++++++++++++++++++++++++++++++++++++++++ tools/libxc/xenctrl.h | 55 +++++++++++++++++++ 3 files changed, 196 insertions(+), 0 deletions(-) create mode 100644 tools/libxc/xc_kexec.c
tools/libxc/Makefile +1 -0
@@ -31,6 +31,7 @@ CTRL_SRCS-y += xc_mem_access.c CTRL_SRCS-y += xc_memshr.c CTRL_SRCS-y += xc_hcall_buf.c CTRL_SRCS-y += xc_foreign_memory.c +CTRL_SRCS-y += xc_kexec.c CTRL_SRCS-y += xtl_core.c CTRL_SRCS-y += xtl_logger_stdio.c CTRL_SRCS-$(CONFIG_X86) += xc_pagetab.c
tools/libxc/xc_kexec.c new file +140 -0
140 lines not on this page · raw message
tools/libxc/xenctrl.h +55 -0
65 lines not on this page · raw message
Signature · 7 lines
1.7.2.5 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
Quoted 27 lines · David Vrabel
The series improves the kexec hypercall by making Xen responsible for loading and relocating the image. This allows kexec to be usable by pv-ops kernels and should allow kexec to be usable from a HVM or PVH privileged domain.
This has now missed the code freeze deadline but could it be considered for 4.3 anyway? kexec isn't a core piece of functionality and I see minimal risk of introducing regressions to Xen as a whole with this series.
The first patch is a simple clean-up.
The second patch allows hypercall structures to be ABI compatible between 32- and 64-bit guests (by reusing stuff present for domctls and sysctls). This seems better than having to keep adding compat handling for new hypercalls etc.
Patch 3 introduces the new ABI.
Patch 4 and 5 nearly completely reimplement the kexec load, unload and exec sub-ops. The old
load_v1sub-op is then implemented on top of the new code.Patch 6 calls the kexec image when dom0 crashes. This avoids having to alter dom0 kernels to do a exec sub-op call on crash -- a
SHUTDOWN_crashby dom0 will trigger the kexec.
Quoted 8 lines
Patches 7 and 8 add the libxc API for the kexec calls. These have been acked-by Ian Campbell already.
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/kexec-tools.git;a=summary
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
...
Daniel
Quoted 27 lines · David Vrabel
The series improves the kexec hypercall by making Xen responsible for loading and relocating the image. This allows kexec to be usable by pv-ops kernels and should allow kexec to be usable from a HVM or PVH privileged domain.
This has now missed the code freeze deadline but could it be considered for 4.3 anyway? kexec isn't a core piece of functionality and I see minimal risk of introducing regressions to Xen as a whole with this series.
The first patch is a simple clean-up.
The second patch allows hypercall structures to be ABI compatible between 32- and 64-bit guests (by reusing stuff present for domctls and sysctls). This seems better than having to keep adding compat handling for new hypercalls etc.
Patch 3 introduces the new ABI.
Patch 4 and 5 nearly completely reimplement the kexec load, unload and exec sub-ops. The old
load_v1sub-op is then implemented on top of the new code.Patch 6 calls the kexec image when dom0 crashes. This avoids having to alter dom0 kernels to do a exec sub-op call on crash -- a
SHUTDOWN_crashby dom0 will trigger the kexec.
Quoted 8 lines
Patches 7 and 8 add the libxc API for the kexec calls. These have been acked-by Ian Campbell already.
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/kexec-tools.git;a=summary
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
...
Daniel
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 6 lines · Daniel Kiper
Quoted 5 lines · David Vrabel
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
Quoted 6 lines
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
Some recent updates to kexec-tools has broken this. If you use the xen-v2 branch of kexec-tools it should be fine.
I suspect the recent change to load 64-bit images about 4G but my unit testing says images above 4G work fine.
Working out what's wrong here is going to push the final patches even further into the code freeze so this will now be a Xen 4.4 candidate.
David
Quoted 6 lines · Daniel Kiper
Quoted 5 lines · David Vrabel
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
Quoted 6 lines
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
Some recent updates to kexec-tools has broken this. If you use the xen-v2 branch of kexec-tools it should be fine.
I suspect the recent change to load 64-bit images about 4G but my unit testing says images above 4G work fine.
Working out what's wrong here is going to push the final patches even further into the code freeze so this will now be a Xen 4.4 candidate.
David
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 9 lines · David Vrabel
Quoted 8 lines · Daniel Kiper
Quoted 6 lines · David Vrabel
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/kexec-tools.git;a=summary
Quoted 7 lines
Quoted 4 lines
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(Some recent updates to kexec-tools has broken this. If you use the xen-v2 branch of kexec-tools it should be fine.
xen-v2 works without any issue...
Quoted 5 lines
I suspect the recent change to load 64-bit images about 4G but my unit testing says images above 4G work fine.
Working out what's wrong here is going to push the final patches even further into the code freeze so this will now be a Xen 4.4 candidate.
If you wish I could put my Reviewed-by and Tested-by for all Xen patches. But please add this fix for memcpy() for patch 5 and repost all Xen patches. However, I could not add Reviewed-by and Tested-by for kexec-tools patches until all problems will be solved.
Daniel
Quoted 9 lines · David Vrabel
Quoted 8 lines · Daniel Kiper
Quoted 6 lines · David Vrabel
The required patch series for kexec-tools have previously been posted and this series has been rebased on the latest kexec-tools and is available from the xen-v3 branch of:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/kexec-tools.git;a=summary
Quoted 7 lines
Quoted 4 lines
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(Some recent updates to kexec-tools has broken this. If you use the xen-v2 branch of kexec-tools it should be fine.
xen-v2 works without any issue...
Quoted 5 lines
I suspect the recent change to load 64-bit images about 4G but my unit testing says images above 4G work fine.
Working out what's wrong here is going to push the final patches even further into the code freeze so this will now be a Xen 4.4 candidate.
If you wish I could put my Reviewed-by and Tested-by for all Xen patches. But please add this fix for memcpy() for patch 5 and repost all Xen patches. However, I could not add Reviewed-by and Tested-by for kexec-tools patches until all problems will be solved.
Daniel
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 5 lines · Daniel Kiper
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
I have now fixed this. Xen was not probably zeroing out trailing pages (only partial pages) when loading a default image (crash was fine).
The kernel does this by allocating and clearing pages and then relocating these as normal but it's wasteful to allocate a bunch of empty pages so I added a IND_ZERO entry type for the indirection pages which gets the relocation code to zero the destination.
See the kexec-v5 branch at:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/xen.git;a=summary
I shall repost this series again once the 4.4 development window is open.
xen/arch/x86/x86_64/kexec_reloc.S +8 -3
@@ -130,13 +130,18 @@ relocate_pages: jmp 3f 2: testq $0x8, %rcx /* is it the source indicator? */ - jz 0b /* Ignore it otherwise */ + jz 2f movq %rcx, %rsi /* For ever source page do a copy */ andq $0xfffffffffffff000, %rsi - movq $512, %rcx rep movsq - + jmp 0b +2: + testq $0x10, %rcx /* is it the zero indicator? */ + jz 0b /* Ignore it otherwise */ + movq $512, %rcx /* Zero the destination page. */ + xorq %rax, %rax + rep stosq jmp 0b 3: ret
xen/common/kimage.c +0 -0
@@ -661,7 +661,7 @@ static int kimage_load_normal_segment(struct
kexec_image *image,
{
unsigned long to_copy;
unsigned long src_offset;
- paddr_t dest;
+ paddr_t dest, end;
int ret;
to_copy = segment->buf_size;
@@ -675,15 +675,13 @@ static int kimage_load_normal_segment(struct
kexec_image *image,
while ( to_copy )
{
unsigned long dest_mfn;
- size_t dest_off;
struct page_info *page;
void *dest_va;
size_t size;
dest_mfn = dest >> PAGE_SHIFT;- dest_off = dest & ~PAGE_MASK;
- size = min(PAGE_SIZE - dest_off, to_copy);
+ size = min_t(unsigned long, PAGE_SIZE, to_copy);
page = kimage_alloc_page(image, dest);
if ( !page )
@@ -693,16 +691,21 @@ static int kimage_load_normal_segment(struct kexec_image *image,
return ret;
dest_va = __map_domain_page(page);
- ret = copy_from_guest_offset(dest_va + dest_off, segment->buf,
src_offset, size);
+ ret = copy_from_guest_offset(dest_va, segment->buf, src_offset,
size);
unmap_domain_page(dest_va);
if ( ret )
return -EFAULT;
to_copy -= size;
src_offset += size;
- dest += size;
+ dest += PAGE_SIZE;
}+ /* Remainder of the destination should be zeroed. */
+ end = segment->dest_maddr + segment->dest_size;
+ for ( ; dest < end; dest += PAGE_SIZE )
+ kimage_add_entry(image, IND_ZERO);
+
return 0;}
xen/include/xen/kimage.h +1 -0
@@ -14,6 +14,7 @@ typedef paddr_t kimage_entry_t;#define IND_INDIRECTION 0x2#define IND_DONE 0x4#define IND_SOURCE 0x8 +#define IND_ZERO 0x10struct kexec_image {uint8_t type;
David
Quoted 5 lines · Daniel Kiper
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(
I have now fixed this. Xen was not probably zeroing out trailing pages (only partial pages) when loading a default image (crash was fine).
The kernel does this by allocating and clearing pages and then relocating these as normal but it's wasteful to allocate a bunch of empty pages so I added a IND_ZERO entry type for the indirection pages which gets the relocation code to zero the destination.
See the kexec-v5 branch at:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/xen.git;a=summary
I shall repost this series again once the 4.4 development window is open.
xen/arch/x86/x86_64/kexec_reloc.S +8 -3
@@ -130,13 +130,18 @@ relocate_pages: jmp 3f 2: testq $0x8, %rcx /* is it the source indicator? */ - jz 0b /* Ignore it otherwise */ + jz 2f movq %rcx, %rsi /* For ever source page do a copy */ andq $0xfffffffffffff000, %rsi - movq $512, %rcx rep movsq - + jmp 0b +2: + testq $0x10, %rcx /* is it the zero indicator? */ + jz 0b /* Ignore it otherwise */ + movq $512, %rcx /* Zero the destination page. */ + xorq %rax, %rax + rep stosq jmp 0b 3: ret
xen/common/kimage.c +0 -0
@@ -661,7 +661,7 @@ static int kimage_load_normal_segment(struct
kexec_image *image,
{
unsigned long to_copy;
unsigned long src_offset;
- paddr_t dest;
+ paddr_t dest, end;
int ret;
to_copy = segment->buf_size;
@@ -675,15 +675,13 @@ static int kimage_load_normal_segment(struct
kexec_image *image,
while ( to_copy )
{
unsigned long dest_mfn;
- size_t dest_off;
struct page_info *page;
void *dest_va;
size_t size;
dest_mfn = dest >> PAGE_SHIFT;- dest_off = dest & ~PAGE_MASK;
- size = min(PAGE_SIZE - dest_off, to_copy);
+ size = min_t(unsigned long, PAGE_SIZE, to_copy);
page = kimage_alloc_page(image, dest);
if ( !page )
@@ -693,16 +691,21 @@ static int kimage_load_normal_segment(struct kexec_image *image,
return ret;
dest_va = __map_domain_page(page);
- ret = copy_from_guest_offset(dest_va + dest_off, segment->buf,
src_offset, size);
+ ret = copy_from_guest_offset(dest_va, segment->buf, src_offset,
size);
unmap_domain_page(dest_va);
if ( ret )
return -EFAULT;
to_copy -= size;
src_offset += size;
- dest += size;
+ dest += PAGE_SIZE;
}+ /* Remainder of the destination should be zeroed. */
+ end = segment->dest_maddr + segment->dest_size;
+ for ( ; dest < end; dest += PAGE_SIZE )
+ kimage_add_entry(image, IND_ZERO);
+
return 0;}
xen/include/xen/kimage.h +1 -0
@@ -14,6 +14,7 @@ typedef paddr_t kimage_entry_t;#define IND_INDIRECTION 0x2#define IND_DONE 0x4#define IND_SOURCE 0x8 +#define IND_ZERO 0x10struct kexec_image {uint8_t type;
David
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Quoted 9 lines · David Vrabel
Quoted 5 lines · Daniel Kiper
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(I have now fixed this. Xen was not probably zeroing out trailing pages (only partial pages) when loading a default image (crash was fine).
Idea is quite good but how many pages in percent are zero? Is it worth to do that? Additionally, I am afraid that this way you are only masking bug in kexec-tools. I think it is better to do bisect on it and find out which patch introduces a bug.
Quoted 10 lines
The kernel does this by allocating and clearing pages and then relocating these as normal but it's wasteful to allocate a bunch of empty pages so I added a
IND_ZEROentry type for the indirection pages which gets the relocation code to zero the destination.See the kexec-v5 branch at:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/xen.git;a=summary
I shall repost this series again once the 4.4 development window is open.
Do you think that at this stage we are not able to introduce this kexec implementation into 4.3? I think that we should try.
Daniel
Quoted 9 lines · David Vrabel
Quoted 5 lines · Daniel Kiper
kexec -e still does not work. I see in my console:
I'm in purgatory
sha256 digests do not match :(I have now fixed this. Xen was not probably zeroing out trailing pages (only partial pages) when loading a default image (crash was fine).
Idea is quite good but how many pages in percent are zero? Is it worth to do that? Additionally, I am afraid that this way you are only masking bug in kexec-tools. I think it is better to do bisect on it and find out which patch introduces a bug.
Quoted 10 lines
The kernel does this by allocating and clearing pages and then relocating these as normal but it's wasteful to allocate a bunch of empty pages so I added a
IND_ZEROentry type for the indirection pages which gets the relocation code to zero the destination.See the kexec-v5 branch at:
http://xenbits.xen.org/gitweb/?p=people/dvrabel/xen.git;a=summary
I shall repost this series again once the 4.4 development window is open.
Do you think that at this stage we are not able to introduce this kexec implementation into 4.3? I think that we should try.
Daniel
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec