domain context infrastructure
v6 cover domain context infrastructure
From: Paul Durrant <[email protected]>
Paul Durrant (5):
xen/common: introduce a new framework for save/restore of 'domain'
context
xen/common/domctl: introduce XEN_DOMCTL_get/setdomaincontext tools/misc: add xen-domctx to present domain context common/domain: add a domain context record for shared_info... tools/libxc: make use of domain context SHARED_INFO record...
.gitignore | 1 + tools/flask/policy/modules/xen.if | 4 +- tools/libxc/include/xenctrl.h | 5 + tools/libxc/xc_domain.c | 56 +++++ tools/libxc/xc_sr_common.c | 67 ++++++ tools/libxc/xc_sr_common.h | 11 +- tools/libxc/xc_sr_common_x86_pv.c | 74 ++++++ tools/libxc/xc_sr_common_x86_pv.h | 3 + tools/libxc/xc_sr_restore_x86_pv.c | 26 +- tools/libxc/xc_sr_save_x86_pv.c | 44 ++-- tools/libxc/xg_save_restore.h | 1 + tools/misc/Makefile | 4 + tools/misc/xen-domctx.c | 278 ++++++++++++++++++++++ xen/common/Makefile | 1 + xen/common/domain.c | 70 ++++++ xen/common/domctl.c | 173 ++++++++++++++ xen/common/save.c | 315 +++++++++++++++++++++++++ xen/include/public/arch-arm/hvm/save.h | 5 + xen/include/public/arch-x86/hvm/save.h | 5 + xen/include/public/domctl.h | 41 ++++ xen/include/public/save.h | 100 ++++++++ xen/include/xen/save.h | 170 +++++++++++++ xen/xsm/flask/hooks.c | 6 + xen/xsm/flask/policy/access_vectors | 4 + 24 files changed, 1418 insertions(+), 46 deletions(-) create mode 100644 tools/misc/xen-domctx.c create mode 100644 xen/common/save.c create mode 100644 xen/include/public/save.h create mode 100644 xen/include/xen/save.h
---
Cc: Andrew Cooper <[email protected]>
Cc: Daniel De Graaf <[email protected]>
Cc: George Dunlap <[email protected]>
Cc: Ian Jackson <[email protected]>
Cc: Jan Beulich <[email protected]>
Cc: Julien Grall <[email protected]>
Cc: "Roger Pau Monné" <[email protected]>
Cc: Stefano Stabellini <[email protected]>
Cc: Volodymyr Babchuk <[email protected]>
Cc: Wei Liu <[email protected]>
Signature · 1 line
2.20.1
PATCH v6 1/5 xen/common: introduce a new framework for save/restore of 'domain' context
To allow enlightened HVM guests (i.e. those that have PV drivers) to be migrated without their co-operation it will be necessary to transfer 'PV' state such as event channel state, grant entry state, etc.
Currently there is a framework (entered via the hvm_save/load() functions) that allows a domain's 'HVM' (architectural) state to be transferred but 'PV' state is also common with pure PV guests and so this framework is not really suitable.
This patch adds the new public header and low level implementation of a new common framework, entered via the domain_save/load() functions. Subsequent patches will introduce other parts of the framework, and code that will make use of it within the current version of the libxc migration stream.
This patch also marks the HVM-only framework as deprecated in favour of the new framework.
---
Cc: Andrew Cooper <[email protected]>
Cc: George Dunlap <[email protected]>
Cc: Ian Jackson <[email protected]>
Cc: Stefano Stabellini <[email protected]>
Cc: Wei Liu <[email protected]>
Cc: Volodymyr Babchuk <[email protected]>
Cc: "Roger Pau Monné" <[email protected]>
v4:
- Addressed further comments from Jan
v3:
- Addressed comments from Julien and Jan
- Save handlers no longer need to state entry length up-front
- Save handlers expected to deal with multiple instances internally
- Entries are now auto-padded to 8 byte boundary
v2:
- Allow multi-stage save/load to avoid the need to double-buffer
- Get rid of the masks and add an 'ignore' flag instead
- Create copy function union to preserve const save buffer
- Deprecate HVM-only framework
--- xen/common/Makefile | 1 + xen/common/save.c | 315 +++++++++++++++++++++++++ xen/include/public/arch-arm/hvm/save.h | 5 + xen/include/public/arch-x86/hvm/save.h | 5 + xen/include/public/save.h | 89 +++++++ xen/include/xen/save.h | 170 +++++++++++++ 6 files changed, 585 insertions(+) create mode 100644 xen/common/save.c create mode 100644 xen/include/public/save.h create mode 100644 xen/include/xen/save.h
xen/common/Makefile +1 -0
@@ -37,6 +37,7 @@ obj-y += radix-tree.o obj-y += rbtree.o obj-y += rcupdate.o obj-y += rwlock.o +obj-y += save.o obj-y += shutdown.o obj-y += softirq.o obj-y += sort.o
xen/common/save.c new file +315 -0
315 lines not on this page · raw message
xen/include/public/arch-arm/hvm/save.h +5 -0
@@ -26,6 +26,11 @@#ifndef __XEN_PUBLIC_HVM_SAVE_ARM_H__#define __XEN_PUBLIC_HVM_SAVE_ARM_H__ +/* +* Further use of HVM state is deprecated. New state records should only +* be added to the domain state header: public/save.h +*/ +#endif /*
xen/include/public/arch-x86/hvm/save.h +5 -0
@@ -648,6 +648,11 @@ struct hvm_msr {*/ #define HVM_SAVE_CODE_MAX 20 +/* +* Further use of HVM state is deprecated. New state records should only +* be added to the domain state header: public/save.h +*/ +#endif /* __XEN_PUBLIC_HVM_SAVE_X86_H__ */ /*
xen/include/public/save.h new file +89 -0
89 lines not on this page · raw message
xen/include/xen/save.h new file +170 -0
170 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v6 2/5 xen/common/domctl: introduce XEN_DOMCTL_get/setdomaincontext
In reply to Paul DurrantThese domctls provide a mechanism to get and set domain context from the toolstack.
---
Cc: Daniel De Graaf <[email protected]>
Cc: Ian Jackson <[email protected]>
Cc: Wei Liu <[email protected]>
Cc: Andrew Cooper <[email protected]>
Cc: George Dunlap <[email protected]>
Cc: Jan Beulich <[email protected]>
Cc: Stefano Stabellini <[email protected]>
v4:
- Add missing zero pad checks
v3:
- Addressed comments from Julien and Jan
- Use vmalloc() rather than xmalloc_bytes()
v2:
- drop mask parameter
- const-ify some more buffers
--- tools/flask/policy/modules/xen.if | 4 +- tools/libxc/include/xenctrl.h | 5 + tools/libxc/xc_domain.c | 56 +++++++++ xen/common/domctl.c | 173 ++++++++++++++++++++++++++++ xen/include/public/domctl.h | 41 +++++++ xen/xsm/flask/hooks.c | 6 + xen/xsm/flask/policy/access_vectors | 4 + 7 files changed, 287 insertions(+), 2 deletions(-)
tools/flask/policy/modules/xen.if +2 -2
@@ -53,7 +53,7 @@ define(`create_domain_common', ` allow $1 $2:domain2 { set_cpu_policy settsc setscheduler setclaim set_vnumainfo get_vnumainfo cacheflush psr_cmt_op psr_alloc soft_reset - resource_map get_cpu_policy }; + resource_map get_cpu_policy setcontext }; allow $1 $2:security check_context; allow $1 $2:shadow enable; allow $1 $2:mmu { map_read map_write adjust memorymap physmap pinpage mmuext_op updatemp };
@@ -97,7 +97,7 @@ define(`migrate_domain_out', ` allow $1 $2:hvm { gethvmc getparam }; allow $1 $2:mmu { stat pageinfo map_read }; allow $1 $2:domain { getaddrsize getvcpucontext pause destroy }; - allow $1 $2:domain2 gettsc; + allow $1 $2:domain2 { gettsc getcontext }; allow $1 $2:shadow { enable disable logdirty }; ')
tools/libxc/include/xenctrl.h +5 -0
@@ -867,6 +867,11 @@ int xc_domain_hvm_setcontext(xc_interface *xch,uint8_t *hvm_ctxt, uint32_t size); +int xc_domain_getcontext (xc_interface *xch,uint32_t domid, +void *ctxt_buf,size_t *size); +int xc_domain_setcontext (xc_interface *xch,uint32_t domid, +const void *ctxt_buf,size_t size); +/** * This function will return guest IO ABI protocol *
tools/libxc/xc_domain.c +56 -0
62 lines not on this page · raw message
xen/common/domctl.c +173 -0
191 lines not on this page · raw message
xen/include/public/domctl.h +41 -0
59 lines not on this page · raw message
xen/xsm/flask/hooks.c +6 -0
@@ -745,6 +745,12 @@ static int flask_domctl(struct domain *d, int cmd)case XEN_DOMCTL_get_cpu_policy:return current_has_perm (d,SECCLASS_DOMAIN2 ,DOMAIN2__GET_CPU_POLICY ); +case XEN_DOMCTL_setdomaincontext: +return current_has_perm (d,SECCLASS_DOMAIN2 ,DOMAIN2__SETCONTEXT ); + +case XEN_DOMCTL_getdomaincontext: +return current_has_perm (d,SECCLASS_DOMAIN2 ,DOMAIN2__GETCONTEXT ); +default :return avc_unknown_permission ("domctl" , cmd); }
xen/xsm/flask/policy/access_vectors +4 -0
@@ -245,6 +245,10 @@ class domain2 resource_map # XEN_DOMCTL_get_cpu_policy get_cpu_policy +# XEN_DOMCTL_setdomaincontext + setcontext +# XEN_DOMCTL_getdomaincontext + getcontext } # Similar to class domain, but primarily contains domctls related to HVM domains
Signature · 1 line
2.20.1
PATCH v6 3/5 tools/misc: add xen-domctx to present domain context
In reply to Paul DurrantThis tool is analogous to 'xen-hvmctx' which presents HVM context. Subsequent patches will add 'dump' functions when new records are introduced.
---
Cc: Andrew Cooper <[email protected]>
Cc: Wei Liu <[email protected]>
NOTE: Ian requested ack from Andrew
v3:
- Re-worked to avoid copying onto stack
- Added optional typecode and instance arguments
v2:
- Change name from 'xen-ctx' to 'xen-domctx'
--- .gitignore | 1 + tools/misc/Makefile | 4 + tools/misc/xen-domctx.c | 200 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 205 insertions(+) create mode 100644 tools/misc/xen-domctx.c
.gitignore +1 -0
@@ -209,6 +209,7 @@ tools/misc/xen_cpuperf tools/misc/xen-cpuid tools/misc/xen-detect tools/misc/xen-diag +tools/misc/xen-domctx tools/misc/xen-tmem-list-parse tools/misc/xen-livepatch tools/misc/xenperf
tools/misc/Makefile +4 -0
@@ -30,6 +30,7 @@ INSTALL_SBIN += xenpm INSTALL_SBIN += xenwatchdogd INSTALL_SBIN += xen-livepatch INSTALL_SBIN += xen-diag +INSTALL_SBIN += xen-domctx INSTALL_SBIN += $(INSTALL_SBIN-y) # Everything to be installed in a private bin/
@@ -108,6 +109,9 @@ xen-livepatch: xen-livepatch.o xen-diag: xen-diag.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenctrl) $(APPEND_LDFLAGS) +xen-domctx: xen-domctx.o + $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenctrl) $(APPEND_LDFLAGS) + xen-lowmemd: xen-lowmemd.o $(CC) $(LDFLAGS) -o $@ $< $(LDLIBS_libxenevtchn) $(LDLIBS_libxenctrl) $(LDLIBS_libxenstore) $(APPEND_LDFLAGS)
tools/misc/xen-domctx.c new file +200 -0
200 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH v6 4/5 common/domain: add a domain context record for shared_info...
In reply to Paul DurrantFrom: Paul Durrant <[email protected]>
... and update xen-domctx to dump some information describing the record.
NOTE: The domain may or may not be using the embedded vcpu_info array so
ultimately separate context records will be added for vcpu_info when this becomes necessary.
---
Cc: Ian Jackson <[email protected]>
Cc: Wei Liu <[email protected]>
Cc: Andrew Cooper <[email protected]>
Cc: George Dunlap <[email protected]>
Cc: Jan Beulich <[email protected]>
Cc: Julien Grall <[email protected]>
Cc: Stefano Stabellini <[email protected]>
v6:
- Only save compat_shared_info buffer if has_32bit_shinfo is set
- Validate flags field in load handler
v5:
- Addressed comments from Julien
v4:
- Addressed comments from Jan
v3:
- Actually dump some of the content of shared_info
v2:
- Drop the header change to define a 'Xen' page size and instead use a variable length struct now that the framework makes this is feasible
- Guard use of 'has_32bit_shinfo' in common code with CONFIG_COMPAT
--- tools/misc/xen-domctx.c | 78 +++++++++++++++++++++++++++++++++++++++ xen/common/domain.c | 70 +++++++++++++++++++++++++++++++++++ xen/include/public/save.h | 13 ++++++- 3 files changed, 160 insertions(+), 1 deletion(-)
tools/misc/xen-domctx.c +78 -0
@@ -31,6 +31,7 @@#include <errno.h> #include <xenctrl.h> +#include <xen-tools/libs.h> #include <xen/xen.h> #include <xen/domctl.h> #include <xen/save.h>
@@ -61,6 +62,82 @@ static void dump_header(void) } +static void print_binary (const char *prefix,const void *val,size_t size, +const char *suffix) +{ +printf ("%s" , prefix); + +while ( size-- ) + { +uint8_t octet = *(const uint8_t *)val++; +unsigned int i; + +for ( i =0 ; i <8 ; i++ ) + { +printf ("%u" , octet &1 ); + octet >>=1 ; + } + } + +printf ("%s" , suffix); +} + +static void dump_shared_info (void ) +{ +DOMAIN_SAVE_TYPE (SHARED_INFO) *s; +bool has_32bit_shinfo; +shared_info_any_t *info; +unsigned int i, n; + +GET_PTR (s); + has_32bit_shinfo = s->flags &DOMAIN_SAVE_32BIT_SHINFO ; + +printf (" SHARED_INFO: has_32bit_shinfo: %s buffer_size: %u\n" , + has_32bit_shinfo ?"true" :"false" , s->buffer_size); + + info = (shared_info_any_t *)s->buffer; + +#define GET_FIELD_PTR (_f) \ + (has_32bit_shinfo ? \ + (const void *)&(info->x32._f) : \ + (const void *)&(info->x64._f)) +#define GET_FIELD_SIZE (_f) \ + (has_32bit_shinfo ? sizeof(info->x32._f) : sizeof(info->x64._f)) +#define GET_FIELD (_f) \ + (has_32bit_shinfo ? info->x32._f : info->x64._f) + + n = has_32bit_shinfo ? +ARRAY_SIZE (info->x32.evtchn_pending) : +ARRAY_SIZE (info->x64.evtchn_pending); + +for ( i =0 ; i < n; i++ ) + { +const char *prefix = !i ? +" evtchn_pending: " : +" " ; + +print_binary (prefix,GET_FIELD_PTR (evtchn_pending[0 ]), +GET_FIELD_SIZE (evtchn_pending[0 ]),"\n" ); + } + +for ( i =0 ; i < n; i++ ) + { +const char *prefix = !i ? +" evtchn_mask: " : +" " ; + +print_binary (prefix,GET_FIELD_PTR (evtchn_mask[0 ]), +GET_FIELD_SIZE (evtchn_mask[0 ]),"\n" ); + } + +printf (" wc: version: %u sec: %u nsec: %u\n" , +GET_FIELD (wc_version),GET_FIELD (wc_sec),GET_FIELD (wc_nsec)); + +#undef GET_FIELD +#undef GET_FIELD_SIZE +#undef GET_FIELD_PTR +} +static void dump_end (void ) {DOMAIN_SAVE_TYPE (END) *e;
@@ -173,6 +250,7 @@ int main(int argc, char **argv)switch (desc->typecode) {case DOMAIN_SAVE_CODE (HEADER ):dump_header ();break ; +case DOMAIN_SAVE_CODE (SHARED_INFO ):dump_shared_info ();break ;case DOMAIN_SAVE_CODE (END ):dump_end ();break ;default :printf ("Unknown type %u: skipping\n" , desc->typecode);
xen/common/domain.c +70 -0
82 lines not on this page · raw message
xen/include/public/save.h +12 -1
@@ -82,7 +82,18 @@ struct domain_save_header { }; DECLARE_DOMAIN_SAVE_TYPE(HEADER, 1, struct domain_save_header); -#define DOMAIN_SAVE_CODE_MAX 1 +struct domain_shared_info_context { +uint32_t flags; + +#define DOMAIN_SAVE_32BIT_SHINFO 0x00000001 + +uint32_t buffer_size; +uint8_t buffer[XEN_FLEX_ARRAY_DIM ];/* Implementation specific size */ +}; + +DECLARE_DOMAIN_SAVE_TYPE(SHARED_INFO, 2, struct domain_shared_info_context); + +#define DOMAIN_SAVE_CODE_MAX 2#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */
Signature · 1 line
2.20.1
Re: [PATCH v6 4/5] common/domain: add a domain context record for shared_info...
Hi Paul,
Quoted 9 lines · Paul Durrant
From: Paul Durrant <[email protected]>
... and update xen-domctx to dump some information describing the record.
NOTE: The domain may or may not be using the embedded
vcpu_infoarray so
ultimately separate context records will be added forvcpu_infowhen this becomes necessary.Signed-off-by Paul Durrant <[email protected]>
Cheers,
Signature · 1 line
Julien Grall
Re: [PATCH v6 4/5] common/domain: add a domain context record for shared_info...
In reply to Paul DurrantQuoted 6 lines · Paul Durrant
xen/common/domain.c +2
-0@@ -1649,6 +1650,75 @@ int continue_hypercall_on_cpu(return 0 ; } +static int save_shared_info (const struct domain *d,struct domain_context *c, +bool dry_run)
xen/common/domain.c int continue_hypercall_on_cpu( · line 1664
Quoted 10 lines
xen/common/domain.c +10
-0+{ +struct domain_shared_info_context ctxt = { +#ifdef CONFIG_COMPAT + .flags =has_32bit_shinfo (d) ?DOMAIN_SAVE_32BIT_SHINFO :0 , + .buffer_size =has_32bit_shinfo (d) ? +sizeof (struct compat_shared_info ) : +sizeof (struct shared_info ), +#else + .buffer_size =sizeof (struct shared_info ), +#endif
To prevent disconnect between the types used here and the actual pointer copied from, I'd have preferred
#ifdef CONFIG_COMPAT
.flags = has_32bit_shinfo(d) ? DOMAIN_SAVE_32BIT_SHINFO : 0,
.buffer_size = has_32bit_shinfo(d) ?
sizeof(d->shared_info->compat) :
sizeof(d->shared_info->native),
#else
.buffer_size = sizeof(*d->shared_info),#endif
But this is secondary, as the types indeed are very unlikely to go out of sync. What's more important is ...
Quoted 22 lines
xen/common/domain.c +22
-0+static int load_shared_info (struct domain *d,struct domain_context *c) +{ +struct domain_shared_info_context ctxt; +size_t hdr_size = offsetof(typeof (ctxt ), buffer); +unsigned int i; +int rc; + + rc =DOMAIN_LOAD_BEGIN (SHARED_INFO , c, &i); +if ( rc ) +return rc; + +if ( i )/* expect only a single instance */ +return -ENXIO ; + + rc =domain_load_data (c, &ctxt, hdr_size); +if ( rc ) +return rc; + +if ( ctxt.buffer_size >sizeof (shared_info_t) || + (ctxt.flags & ~DOMAIN_SAVE_32BIT_SHINFO ) ) +return -EINVAL ; +
xen/common/domain.c int continue_hypercall_on_cpu( · line 1715
Quoted 10 lines
xen/common/domain.c +10
-0+ if ( ctxt.flags & DOMAIN_SAVE_32BIT_SHINFO ) +#ifdef CONFIG_COMPAT +has_32bit_shinfo (d) = true; +#else +return -EINVAL ; +#endif + + rc =domain_load_data (c, d->shared_info,sizeof (shared_info_t)); +if ( rc ) +return rc;
... the still insufficient checking here. You shouldn't accept more than sizeof(d->shared_info->compat) worth of data in the compat case if you also don't accept more than sizeof(shared_info_t) in the native case. To save another round trip I'll offer to make the adjustments while committing, but patches 3 and 5 want Andrew's ack first anyway.
Jan
RE: [PATCH v6 4/5] common/domain: add a domain context record for shared_info...
Quoted 79 lines
-----Original Message-----
From: Jan Beulich <[email protected]>
Sent: 28 May 2020 10:42
To: Paul Durrant <[email protected]>
Cc: [email protected]; Durrant, Paul <[email protected]>; Ian Jackson <[email protected]>; Wei Liu <[email protected]>; Andrew Cooper <[email protected]>; George Dunlap <[email protected]>; Julien Grall <[email protected]>; Stefano Stabellini <[email protected]>
Subject: RE: [EXTERNAL] [PATCH v6 4/5] common/domain: add a domain context record forshared_info...CAUTION: This email originated from outside of the organization. Do not click links or open attachments unless you can confirm the sender and know the content is safe.
Quoted 6 lines · Paul Durrant
xen/common/domain.c +2
-0@@ -1649,6 +1650,75 @@ int continue_hypercall_on_cpu(return 0 ; } +static int save_shared_info (const struct domain *d,struct domain_context *c, +bool dry_run)xen/common/domain.c int continue_hypercall_on_cpu( · line 1664
Quoted 10 lines
xen/common/domain.c +10
-0+{ +struct domain_shared_info_context ctxt = { +#ifdef CONFIG_COMPAT + .flags =has_32bit_shinfo (d) ?DOMAIN_SAVE_32BIT_SHINFO :0 , + .buffer_size =has_32bit_shinfo (d) ? +sizeof (struct compat_shared_info ) : +sizeof (struct shared_info ), +#else + .buffer_size =sizeof (struct shared_info ), +#endifTo prevent disconnect between the types used here and the actual pointer copied from, I'd have preferred
#ifdef CONFIG_COMPAT .flags = has_32bit_shinfo(d) ? DOMAIN_SAVE_32BIT_SHINFO : 0, .buffer_size = has_32bit_shinfo(d) ? sizeof(d->shared_info->compat) : sizeof(d->shared_info->native), #else .buffer_size = sizeof(*d->shared_info),#endif
But this is secondary, as the types indeed are very unlikely to go out of sync. What's more important is ...
Quoted 31 lines
xen/common/domain.c +31
-0+static int load_shared_info (struct domain *d,struct domain_context *c) +{ +struct domain_shared_info_context ctxt; +size_t hdr_size = offsetof(typeof (ctxt ), buffer); +unsigned int i; +int rc; + + rc =DOMAIN_LOAD_BEGIN (SHARED_INFO , c, &i); +if ( rc ) +return rc; + +if ( i )/* expect only a single instance */ +return -ENXIO ; + + rc =domain_load_data (c, &ctxt, hdr_size); +if ( rc ) +return rc; + +if ( ctxt.buffer_size >sizeof (shared_info_t) || + (ctxt.flags & ~DOMAIN_SAVE_32BIT_SHINFO ) ) +return -EINVAL ; + + if ( ctxt.flags & DOMAIN_SAVE_32BIT_SHINFO ) +#ifdef CONFIG_COMPAT +has_32bit_shinfo (d) = true; +#else +return -EINVAL ; +#endif + + rc =domain_load_data (c, d->shared_info,sizeof (shared_info_t)); +if ( rc )
Quoted 8 lines
Review int continue_hypercall_on_cpu( · line 1696
Quoted 1 line
(quoted diff) +1
-0+ return rc;... the still insufficient checking here. You shouldn't accept more than
sizeof(d->shared_info->compat)worth of data in the compat case if you also don't accept more thansizeof(shared_info_t)in the native case. To save another round trip I'll offer to make the adjustments while committing, but patches 3 and 5 want Andrew's ack first anyway.
Ok, thanks.
Paul
Quoted 2 lines
Jan
PATCH v6 5/5 tools/libxc: make use of domain context SHARED_INFO record...
In reply to Paul Durrant... in the save/restore code.
This patch replaces direct mapping of the shared_info_frame (retrieved using XEN_DOMCTL_getdomaininfo) with save/load of the domain context SHARED_INFO record.
No modifications are made to the definition of the migration stream at this point. Subsequent patches will define a record in the libxc domain image format for passing domain context and convert the save/restore code to use that.
---
Cc: Andrew Cooper <[email protected]>
Cc: Ian Jackson <[email protected]>
Cc: Wei Liu <[email protected]>
NOTE: Ian requested ack from Andrew
v5:
- Added BUILD_BUG_ON() in write_shared_info() to ensure copied data is not bigger than the record buffer
v4:
- write_shared_info() now needs to allocate the record data since the shared info buffer is smaller than PAGE_SIZE
v3:
- Moved basic get/set domain context functions to common code
v2:
- Re-based (now making use of DOMAIN_SAVE_FLAG_IGNORE)
--- tools/libxc/xc_sr_common.c | 67 +++++++++++++++++++++++++++ tools/libxc/xc_sr_common.h | 11 ++++- tools/libxc/xc_sr_common_x86_pv.c | 74 ++++++++++++++++++++++++++++++ tools/libxc/xc_sr_common_x86_pv.h | 3 ++ tools/libxc/xc_sr_restore_x86_pv.c | 26 ++++------- tools/libxc/xc_sr_save_x86_pv.c | 44 ++++++++---------- tools/libxc/xg_save_restore.h | 1 + 7 files changed, 182 insertions(+), 44 deletions(-)
tools/libxc/xc_sr_common.c +67 -0
@@ -138,6 +138,73 @@ int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec)return 0 ; }; +int get_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +size_t len =0 ; +int rc; + +if ( ctx->domain_context.buffer ) + { +ERROR ("Domain context already present" ); +return -1 ; + } + + rc =xc_domain_getcontext (xch, ctx->domid,NULL , &len); +if ( rc <0 ) + { +PERROR ("Unable to get size of domain context" ); +return -1 ; + } + + ctx->domain_context.buffer =malloc (len); +if ( !ctx->domain_context.buffer ) + { +PERROR ("Unable to allocate memory for domain context" ); +return -1 ; + } + + rc =xc_domain_getcontext (xch, ctx->domid, ctx->domain_context.buffer, + &len); +if ( rc <0 ) + { +PERROR ("Unable to get domain context" ); +return -1 ; + } + + ctx->domain_context.len = len; + +return 0 ; +} + +int set_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +int rc; + +if ( !ctx->domain_context.buffer ) + { +ERROR ("Domain context not present" ); +return -1 ; + } + + rc =xc_domain_setcontext (xch, ctx->domid, ctx->domain_context.buffer, + ctx->domain_context.len); + +if ( rc <0 ) + { +PERROR ("Unable to set domain context" ); +return -1 ; + } + +return 0 ; +} + +void common_cleanup (struct xc_sr_context *ctx) +{ +free (ctx->domain_context.buffer); +} +static void __attribute__((unused))build_assertions (void ) {BUILD_BUG_ON (sizeof (struct xc_sr_ihdr ) !=24 );
tools/libxc/xc_sr_common.h +10 -1
@@ -208,6 +208,11 @@ struct xc_sr_contextxc_dominfo_t dominfo; +struct { +void *buffer; +unsigned int len; + } domain_context; +union /* Common save or restore data. */ { struct /* Save data. */
@@ -314,7 +319,7 @@ struct xc_sr_context/* The guest pfns containing the p2m leaves */ xen_pfn_t *p2m_pfns; -/* Read-only mapping of guests shared info page */ +/* Pointer to shared_info (located in context buffer) */ shared_info_any_t *shinfo;/* p2m generation count for verifying validity of local p2m. */
@@ -425,6 +430,10 @@ int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec);int populate_pfns (struct xc_sr_context *ctx,unsigned int count,const xen_pfn_t *original_pfns,const uint32_t *types); +int get_domain_context (struct xc_sr_context *ctx); +int set_domain_context (struct xc_sr_context *ctx); +void common_cleanup (struct xc_sr_context *ctx); +#endif /* * Local variables:
tools/libxc/xc_sr_common_x86_pv.c +74 -0
80 lines not on this page · raw message
tools/libxc/xc_sr_common_x86_pv.h +3 -0
@@ -97,6 +97,9 @@ int x86_pv_domain_info(struct xc_sr_context *ctx);*/ int x86_pv_map_m2p (struct xc_sr_context *ctx); +int x86_pv_get_shinfo (struct xc_sr_context *ctx); +int x86_pv_set_shinfo (struct xc_sr_context *ctx); +#endif /* * Local variables:
tools/libxc/xc_sr_restore_x86_pv.c +8 -18
@@ -865,7 +865,7 @@ static int handle_shared_info(struct xc_sr_context *ctx,xc_interface *xch = ctx->xch;unsigned int i;int rc =-1 ; -shared_info_any_t *guest_shinfo =NULL ; +shared_info_any_t *guest_shinfo;const shared_info_any_t *old_shinfo = rec->data;if ( !ctx->x86.pv.restore.seen_pv_info )
@@ -878,18 +878,14 @@ static int handle_shared_info(struct xc_sr_context *ctx, {ERROR ("X86_PV_SHARED_INFO record wrong size: length %u" ", expected 4096" , rec->length); - goto err; +return -1 ; } - guest_shinfo =xc_map_foreign_range ( - xch, ctx->domid,PAGE_SIZE ,PROT_READ |PROT_WRITE , - ctx->dominfo.shared_info_frame); -if ( !guest_shinfo ) - { -PERROR ("Failed to map Shared Info at mfn %#lx" , - ctx->dominfo.shared_info_frame); - goto err; - } + rc =x86_pv_get_shinfo (ctx); +if ( rc ) +return rc; + + guest_shinfo = ctx->x86.pv.shinfo;MEMCPY_FIELD (guest_shinfo, old_shinfo, vcpu_info, ctx->x86.pv.width);MEMCPY_FIELD (guest_shinfo, old_shinfo, arch, ctx->x86.pv.width);
@@ -904,13 +900,7 @@ static int handle_shared_info(struct xc_sr_context *ctx,MEMSET_ARRAY_FIELD (guest_shinfo, evtchn_mask,0xff , ctx->x86.pv.width); - rc =0 ; - - err: -if ( guest_shinfo ) -munmap (guest_shinfo,PAGE_SIZE ); - -return rc; +return x86_pv_set_shinfo (ctx); }/* restore_ops function. */
tools/libxc/xc_sr_save_x86_pv.c +19 -25
76 lines not on this page · raw message
tools/libxc/xg_save_restore.h +1 -0
@@ -19,6 +19,7 @@#include <xen/foreign/x86_32.h> #include <xen/foreign/x86_64.h> +#include <xen/save.h> /* ** We process save/restore/migrate in batches of pages; the below
Signature · 1 line
2.20.1
Re: [PATCH v6 5/5] tools/libxc: make use of domain context SHARED_INFO record...
Quoted 6 lines · Paul Durrant
... in the save/restore code.
This patch replaces direct mapping of the
shared_info_frame(retrieved usingXEN_DOMCTL_getdomaininfo) with save/load of the domain contextSHARED_INFOrecord.
Quoted 6 lines
No modifications are made to the definition of the migration stream at this point. Subsequent patches will define a record in the libxc domain image format for passing domain context and convert the save/restore code to use that.
Signed-off-by Paul Durrant <[email protected]>
I was going to fix up the remaining issues and commit this, but there is a rather major problem in the way. Therefore, here is a rather more full review.
Quoted 23 lines
tools/libxc/xc_sr_common.c +15
-0@@ -138,6 +138,73 @@ int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec)return 0 ; }; +int get_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +size_t len =0 ; +int rc; + +if ( ctx->domain_context.buffer ) + { +ERROR ("Domain context already present" ); +return -1 ; + } + + rc =xc_domain_getcontext (xch, ctx->domid,NULL , &len); +if ( rc <0 ) + {
tools/libxc/xc_sr_common.c int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec) · line 165
Quoted 10 lines
tools/libxc/xc_sr_common.c +10
-0+PERROR ("Unable to get size of domain context" ); +return -1 ; + } + + ctx->domain_context.buffer =malloc (len); +if ( !ctx->domain_context.buffer ) + { +PERROR ("Unable to allocate memory for domain context" ); +return -1 ; + }
There is an xc_sr_blob interface, as this is a common pattern.
Quoted 30 lines
tools/libxc/xc_sr_common.c +30
-0+ + rc =xc_domain_getcontext (xch, ctx->domid, ctx->domain_context.buffer, + &len); +if ( rc <0 ) + { +PERROR ("Unable to get domain context" ); +return -1 ; + } + + ctx->domain_context.len = len; + +return 0 ; +} + +int set_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +int rc; + +if ( !ctx->domain_context.buffer ) + { +ERROR ("Domain context not present" ); +return -1 ; + } + + rc =xc_domain_setcontext (xch, ctx->domid, ctx->domain_context.buffer, + ctx->domain_context.len); + +if ( rc <0 ) + {
tools/libxc/xc_sr_common.c int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec) · line 205
Quoted 10 lines
tools/libxc/xc_sr_common.c +10
-0+PERROR ("Unable to set domain context" ); +return -1 ; + } + +return 0 ; +} + +void common_cleanup (struct xc_sr_context *ctx) +{ +free (ctx->domain_context.buffer);
There is only a single caller to this function, so there is a (possibly latent) memory leak.
Quoted 10 lines
tools/libxc/xc_sr_common.c +2
-0+} +static void __attribute__((unused))build_assertions (void ) {BUILD_BUG_ON (sizeof (struct xc_sr_ihdr ) !=24 );tools/libxc/xc_sr_common.h +0
-0
tools/libxc/xc_sr_common.h struct xc_sr_context · line 214
Quoted 7 lines
tools/libxc/xc_sr_common.h +4
-0@@ -208,6 +208,11 @@ struct xc_sr_contextxc_dominfo_t dominfo; +struct { +void *buffer; +unsigned int len; + } domain_context;
As noted above, xc_sr_blob domain_context;
Quoted 23 lines
tools/libxc/xc_sr_restore_x86_pv.c +2
-4@@ -865,7 +865,7 @@ static int handle_shared_info(struct xc_sr_context *ctx,xc_interface *xch = ctx->xch;unsigned int i;int rc =-1 ; -shared_info_any_t *guest_shinfo =NULL ; +shared_info_any_t *guest_shinfo;const shared_info_any_t *old_shinfo = rec->data;if ( !ctx->x86.pv.restore.seen_pv_info )@@ -878,18 +878,14 @@ static int handle_shared_info(struct xc_sr_context *ctx, {ERROR ("X86_PV_SHARED_INFO record wrong size: length %u" ", expected 4096" , rec->length); - goto err; +return -1 ; } - guest_shinfo = xc_map_foreign_range( - xch, ctx->domid, PAGE_SIZE, PROT_READ | PROT_WRITE,
tools/libxc/xc_sr_restore_x86_pv.c static int handle_shared_info(struct xc_sr_context *ctx, · line 886
Quoted 10 lines
tools/libxc/xc_sr_restore_x86_pv.c +3
-7- ctx->dominfo.shared_info_frame); -if ( !guest_shinfo ) - { -PERROR ("Failed to map Shared Info at mfn %#lx" , - ctx->dominfo.shared_info_frame); - goto err; - } + rc =x86_pv_get_shinfo (ctx); +if ( rc ) +return rc;
If I'm following this logic correctly, we're now in the final throws of completing migration with data in hand, and we ask the hypervisor to gather the entire domain context for this (not-yet-run) guest, copy it (twice, even) down into userspace, so we can scan through it to find the appropriate tag, copy less than a page's worth of data, then pass the full buffer back to Xen to unserialise the whole thing over the guest.
The restore path shouldn't be calling DOMCTL_get* at all. It is conceptually wrong, and a waste of time/effort which would be better spent with the guest unpaused.
What the restore path should be doing is passing data from the stream, straight into DOMCTL_set* (and attempting to do this will probably demonstrate why hvmctxt was an especially poor API to copy). The layout of existing migration-v2 blocks was designed around blobs which Xen produces and consumes directly, specifically to minimise the processing required.
I think it is a layering violation to have libxc pick apart and reframe the internals of another layers' blob.
What is not currently clear is whether the domain context wants sending as a discrete blob itself (and have a new chunk type allocated for the purpose), or each bit of it is going to want picking apart. This largely depends on what else is going in the blob at a Xen level.
Also, I'd like to see the plans for the HVM side of this logic before deciding on whether the PV side is appropriate. I know we have a dedicated SHARED_INFO record right now, but it would be fine (AFAICT) to relax the migration spec to state that one of {SHARED_INFO, DOMAIN_CONTEXT} must be sent for PV.
Quoted 11 lines
tools/libxc/xc_sr_restore_x86_pv.c +2
-1@@ -854,13 +835,27 @@ static int write_x86_pv_p2m_frames(struct xc_sr_context *ctx)*/ static int write_shared_info (struct xc_sr_context *ctx) { +xc_interface *xch = ctx->xch;struct xc_sr_record rec = { .type =REC_TYPE_SHARED_INFO , .length =PAGE_SIZE , - .data = ctx->x86.pv.shinfo, }; +int rc;
tools/libxc/xc_sr_restore_x86_pv.c static int write_x86_pv_p2m_frames(struct xc_sr_context *ctx) · line 852
Quoted 10 lines
tools/libxc/xc_sr_restore_x86_pv.c +8
-1-return write_record (ctx, &rec); +if ( !(rec.data =calloc (1 ,PAGE_SIZE )) ) + { +ERROR ("Cannot allocate buffer for SHARED_INFO data" ); +return -1 ; + } + +BUILD_BUG_ON (sizeof (*ctx->x86.pv.shinfo) >PAGE_SIZE ); +memcpy (rec.data, ctx->x86.pv.shinfo,sizeof (*ctx->x86.pv.shinfo));
These are some very contorted hoops to extend the data size sent.
write_split_record() is the the tool to use here, although the above suggestions may render this change unnecessary.
Quoted 13 lines
tools/libxc/xc_sr_restore_x86_pv.c +1
-1@@ -1041,7 +1036,7 @@ static int x86_pv_setup(struct xc_sr_context *ctx)if ( rc )return rc; - rc =map_shinfo (ctx); + rc =x86_pv_get_shinfo (ctx);if ( rc )return rc;@@ -1112,12 +1107,11 @@ static int x86_pv_cleanup(struct xc_sr_context *ctx)if ( ctx->x86.pv.p2m )munmap (ctx->x86.pv.p2m, ctx->x86.pv.p2m_frames *PAGE_SIZE );
tools/libxc/xc_sr_restore_x86_pv.c static int x86_pv_cleanup(struct xc_sr_context *ctx) · line 1116
Quoted 10 lines
tools/libxc/xc_sr_restore_x86_pv.c +2
-3-if ( ctx->x86.pv.shinfo ) -munmap (ctx->x86.pv.shinfo,PAGE_SIZE ); -if ( ctx->x86.pv.m2p )munmap (ctx->x86.pv.m2p, ctx->x86.pv.nr_m2p_frames *PAGE_SIZE ); +common_cleanup (ctx); +return 0 ; }
This pair highlights an asymmetry in the patch, which will need fixing by whomever adds a second field to domain_context. Obtaining the context for use should shouldn't be a hidden side effect of getting the shared info.
~Andrew
RE: [PATCH v6 5/5] tools/libxc: make use of domain context SHARED_INFO record...
Quoted 19 lines
-----Original Message-----
From: Andrew Cooper <[email protected]> On Behalf Of Andrew Cooper
Sent: 30 May 2020 01:30
To: Paul Durrant <[email protected]>; [email protected]
Cc: Paul Durrant <[email protected]>; Ian Jackson <[email protected]>; Wei Liu <[email protected]>
Subject: Re: [PATCH v6 5/5]tools/libxc: make use of domain contextSHARED_INFOrecord...Quoted 11 lines · Paul Durrant
... in the save/restore code.
This patch replaces direct mapping of the
shared_info_frame(retrieved usingXEN_DOMCTL_getdomaininfo) with save/load of the domain contextSHARED_INFOrecord.No modifications are made to the definition of the migration stream at this point. Subsequent patches will define a record in the libxc domain image format for passing domain context and convert the save/restore code to use that.
Quoted 6 lines
Quoted 1 line
Signed-off-by Paul Durrant <[email protected]>I was going to fix up the remaining issues and commit this, but there is a rather major problem in the way. Therefore, here is a rather more full review.
Thanks, but I have to say that this is quite late, coming in v6.
Quoted 27 lines
Quoted 27 lines
tools/libxc/xc_sr_common.c +19
-0@@ -138,6 +138,73 @@ int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec)return 0 ; }; +int get_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +size_t len =0 ; +int rc; + +if ( ctx->domain_context.buffer ) + { +ERROR ("Domain context already present" ); +return -1 ; + } + + rc =xc_domain_getcontext (xch, ctx->domid,NULL , &len); +if ( rc <0 ) + { +PERROR ("Unable to get size of domain context" ); +return -1 ; + } +
Quoted 9 lines
tools/libxc/xc_sr_common.c int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec) · line 165
Quoted 6 lines
tools/libxc/xc_sr_common.c +6
-0+ ctx->domain_context.buffer =malloc (len); +if ( !ctx->domain_context.buffer ) + { +PERROR ("Unable to allocate memory for domain context" ); +return -1 ; + }There is an
xc_sr_blobinterface, as this is a common pattern.
Ok.
Quoted 96 lines
Quoted 30 lines
tools/libxc/xc_sr_common.c +30
-0+ + rc =xc_domain_getcontext (xch, ctx->domid, ctx->domain_context.buffer, + &len); +if ( rc <0 ) + { +PERROR ("Unable to get domain context" ); +return -1 ; + } + + ctx->domain_context.len = len; + +return 0 ; +} + +int set_domain_context (struct xc_sr_context *ctx) +{ +xc_interface *xch = ctx->xch; +int rc; + +if ( !ctx->domain_context.buffer ) + { +ERROR ("Domain context not present" ); +return -1 ; + } + + rc =xc_domain_setcontext (xch, ctx->domid, ctx->domain_context.buffer, + ctx->domain_context.len); + +if ( rc <0 ) + {tools/libxc/xc_sr_common.c int read_record(struct xc_sr_context *ctx, int fd, struct xc_sr_record *rec) · line 205
Quoted 10 lines
tools/libxc/xc_sr_common.c +10
-0+PERROR ("Unable to set domain context" ); +return -1 ; + } + +return 0 ; +} + +void common_cleanup (struct xc_sr_context *ctx) +{ +free (ctx->domain_context.buffer);There is only a single caller to this function, so there is a (possibly latent) memory leak.
Quoted 10 lines
tools/libxc/xc_sr_common.c +2
-0+} +static void __attribute__((unused))build_assertions (void ) {BUILD_BUG_ON (sizeof (struct xc_sr_ihdr ) !=24 );tools/libxc/xc_sr_common.h +0
-0tools/libxc/xc_sr_common.h struct xc_sr_context · line 214
Quoted 7 lines
tools/libxc/xc_sr_common.h +4
-0@@ -208,6 +208,11 @@ struct xc_sr_contextxc_dominfo_t dominfo; +struct { +void *buffer; +unsigned int len; + } domain_context;As noted above,
xc_sr_blobdomain_context;Quoted 32 lines
tools/libxc/xc_sr_restore_x86_pv.c +4
-11@@ -865,7 +865,7 @@ static int handle_shared_info(struct xc_sr_context *ctx,xc_interface *xch = ctx->xch;unsigned int i;int rc =-1 ; -shared_info_any_t *guest_shinfo =NULL ; +shared_info_any_t *guest_shinfo;const shared_info_any_t *old_shinfo = rec->data;if ( !ctx->x86.pv.restore.seen_pv_info )@@ -878,18 +878,14 @@ static int handle_shared_info(struct xc_sr_context *ctx, {ERROR ("X86_PV_SHARED_INFO record wrong size: length %u" ", expected 4096" , rec->length); - goto err; +return -1 ; } - guest_shinfo =xc_map_foreign_range ( - xch, ctx->domid,PAGE_SIZE ,PROT_READ |PROT_WRITE , - ctx->dominfo.shared_info_frame); -if ( !guest_shinfo ) - { -PERROR ("Failed to map Shared Info at mfn %#lx" , - ctx->dominfo.shared_info_frame); - goto err; - } + rc =x86_pv_get_shinfo (ctx); +if ( rc )
Quoted 9 lines
tools/libxc/xc_sr_restore_x86_pv.c static int handle_shared_info(struct xc_sr_context *ctx, · line 886
Quoted 1 line
tools/libxc/xc_sr_restore_x86_pv.c +1
-0+return rc;If I'm following this logic correctly, we're now in the final throws of completing migration with data in hand, and we ask the hypervisor to gather the entire domain context for this (not-yet-run) guest, copy it (twice, even) down into userspace, so we can scan through it to find the appropriate tag, copy less than a page's worth of data, then pass the full buffer back to Xen to unserialise the whole thing over the guest.
That is the case at the moment yes. I do state quite clearly in the commit comment:
"No modifications are made to the definition of the migration stream at this point. Subsequent patches will define a record in the libxc domain image format for passing domain context and convert the save/restore code to use that."
Quoted 4 lines
The restore path shouldn't be calling DOMCTL_get* at all. It is conceptually wrong, and a waste of time/effort which would be better spent with the guest unpaused.
I refer to the quoted text above.
Quoted 10 lines
What the restore path should be doing is passing data from the stream, straight into DOMCTL_set* (and attempting to do this will probably demonstrate why hvmctxt was an especially poor API to copy). The layout of existing migration-v2 blocks was designed around blobs which Xen produces and consumes directly, specifically to minimise the processing required.
I think it is a layering violation to have libxc pick apart and reframe the internals of another layers' blob.
Again, that was a pragmatic choice at this stage. The layering violation is already there; I have not added code to pick apart the shared info... it was there already. I also don't think picking apart the domain context buffer is necessarily a layering violation.
Quoted 11 lines
What is not currently clear is whether the domain context wants sending as a discrete blob itself (and have a new chunk type allocated for the purpose), or each bit of it is going to want picking apart. This largely depends on what else is going in the blob at a Xen level.
Also, I'd like to see the plans for the HVM side of this logic before deciding on whether the PV side is appropriate. I know we have a dedicated
SHARED_INFOrecord right now, but it would be fine (AFAICT) to relax the migration spec to state that one of {SHARED_INFO,DOMAIN_CONTEXT} must be sent for PV.
If you object to this interim step then I think I will indeed abstract away from SHARED_INFO instead. Very little of it is actually used in PV migration anyway and different parts will be needed for guest transparent live migration.
Quoted 24 lines
Quoted 11 lines
tools/libxc/xc_sr_restore_x86_pv.c +2
-1@@ -854,13 +835,27 @@ static int write_x86_pv_p2m_frames(struct xc_sr_context *ctx)*/ static int write_shared_info (struct xc_sr_context *ctx) { +xc_interface *xch = ctx->xch;struct xc_sr_record rec = { .type =REC_TYPE_SHARED_INFO , .length =PAGE_SIZE , - .data = ctx->x86.pv.shinfo, }; +int rc;tools/libxc/xc_sr_restore_x86_pv.c static int write_x86_pv_p2m_frames(struct xc_sr_context *ctx) · line 852
Quoted 10 lines
tools/libxc/xc_sr_restore_x86_pv.c +8
-1-return write_record (ctx, &rec); +if ( !(rec.data =calloc (1 ,PAGE_SIZE )) ) + { +ERROR ("Cannot allocate buffer for SHARED_INFO data" ); +return -1 ; + } + +BUILD_BUG_ON (sizeof (*ctx->x86.pv.shinfo) >PAGE_SIZE ); +memcpy (rec.data, ctx->x86.pv.shinfo,sizeof (*ctx->x86.pv.shinfo));These are some very contorted hoops to extend the data size sent.
Quoted 3 lines
write_split_record()is the the tool to use here, although the above suggestions may render this change unnecessary.
Indeed.
Quoted 19 lines
Quoted 19 lines
tools/libxc/xc_sr_restore_x86_pv.c +1
-4@@ -1041,7 +1036,7 @@ static int x86_pv_setup(struct xc_sr_context *ctx)if ( rc )return rc; - rc =map_shinfo (ctx); + rc =x86_pv_get_shinfo (ctx);if ( rc )return rc;@@ -1112,12 +1107,11 @@ static int x86_pv_cleanup(struct xc_sr_context *ctx)if ( ctx->x86.pv.p2m )munmap (ctx->x86.pv.p2m, ctx->x86.pv.p2m_frames *PAGE_SIZE ); -if ( ctx->x86.pv.shinfo ) -munmap (ctx->x86.pv.shinfo,PAGE_SIZE ); -if ( ctx->x86.pv.m2p )munmap (ctx->x86.pv.m2p, ctx->x86.pv.nr_m2p_frames *PAGE_SIZE );
Quoted 10 lines
tools/libxc/xc_sr_restore_x86_pv.c static int x86_pv_cleanup(struct xc_sr_context *ctx) · line 1116
Quoted 4 lines
tools/libxc/xc_sr_restore_x86_pv.c +2
-0+common_cleanup (ctx); +return 0 ; }This pair highlights an asymmetry in the patch, which will need fixing by whomever adds a second field to
domain_context. Obtaining the context for use should shouldn't be a hidden side effect of getting the shared info.
Ok.
Paul
Quoted 1 line
~Andrew