32-on-64 memory ops
RFC PATCH 9/17 32-on-64 memory ops
xen/arch/x86/domain.c +202 -27
@@ -114,6 +114,58 @@ void dump_pageframe_info(struct domain * } } +#ifdef CONFIG_COMPAT +int setup_arg_xlat_area (struct domain *d,unsigned int vcpu_id,l4_pgentry_t *l4tab) +{ +unsigned i; +struct page_info *pg; + +if ( !d->arch.mm_arg_xlat_l3 ) + { + pg =alloc_domheap_page (NULL ); +if ( !pg ) +return -ENOMEM ; + d->arch.mm_arg_xlat_l3 =clear_page (page_to_virt (pg)); + } + + l4tab[l4_table_offset (COMPAT_ARG_XLAT_VIRT_BASE )] = +l4e_from_paddr (__pa (d->arch.mm_arg_xlat_l3), __PAGE_HYPERVISOR); + +for ( i =0 ; i <COMPAT_ARG_XLAT_PAGES ; ++i ) + { +unsigned long va =COMPAT_ARG_XLAT_VIRT_START (vcpu_id) + i *PAGE_SIZE ; +l2_pgentry_t *l2tab; +l1_pgentry_t *l1tab; + +if ( !l3e_get_intpte (d->arch.mm_arg_xlat_l3[l3_table_offset (va)]) ) + { + pg =alloc_domheap_page (NULL ); +if ( !pg ) +return -ENOMEM ; +clear_page (page_to_virt (pg)); + d->arch.mm_arg_xlat_l3[l3_table_offset (va)] =l3e_from_page (pg,PAGE_HYPERVISOR ); + } + l2tab =l3e_to_l2e (d->arch.mm_arg_xlat_l3[l3_table_offset (va)]); +if ( !l2e_get_intpte (l2tab[l2_table_offset (va)]) ) + { + pg =alloc_domheap_page (NULL ); +if ( !pg ) +return -ENOMEM ; +clear_page (page_to_virt (pg)); + l2tab[l2_table_offset (va)] =l2e_from_page (pg,PAGE_HYPERVISOR ); + } + l1tab =l2e_to_l1e (l2tab[l2_table_offset (va)]); +BUG_ON (l1e_get_intpte (l1tab[l1_table_offset (va)])); + pg =alloc_domheap_page (NULL ); +if ( !pg ) +return -ENOMEM ; + l1tab[l1_table_offset (va)] =l1e_from_page (pg,PAGE_HYPERVISOR ); + } + +return 0 ; +} +#endif +struct vcpu *alloc_vcpu_struct (struct domain *d,unsigned int vcpu_id) {struct vcpu *v;
@@ -161,6 +213,13 @@ struct vcpu *alloc_vcpu_struct(struct dol4e_from_paddr (__pa (d->arch.mm_perdomain_l3), __PAGE_HYPERVISOR); v->arch.guest_table =pagetable_from_page (pg); v->arch.guest_table_user = v->arch.guest_table; + +if (setup_arg_xlat_area (d, vcpu_id, l4tab) <0 ) + { +free_xenheap_page (l4tab); +xfree (v); +return NULL ; + } }#endif
@@ -273,6 +332,46 @@ void arch_domain_destroy(struct domain *free_domheap_page (virt_to_page (d->arch.mm_perdomain_l3));#endif +#ifdef CONFIG_COMPAT +if ( d->arch.mm_arg_xlat_l3 ) + { +struct page_info *pg; +unsigned l3; + +for ( l3 =0 ; l3 <L3_PAGETABLE_ENTRIES ; ++l3 ) + { +if (l3e_get_intpte (d->arch.mm_arg_xlat_l3[l3]) ) + { +l2_pgentry_t *l2tab =l3e_to_l2e (d->arch.mm_arg_xlat_l3[l3]); +unsigned l2; + +for ( l2 =0 ; l2 <L2_PAGETABLE_ENTRIES ; ++l2 ) + { +if (l2e_get_intpte (l2tab[l2]) ) + { +l1_pgentry_t *l1tab =l2e_to_l1e (l2tab[l2]); +unsigned l1; + +for ( l1 =0 ; l1 <L1_PAGETABLE_ENTRIES ; ++l1 ) + { +if (l1e_get_intpte (l1tab[l1]) ) + { + pg =l1e_get_page (l1tab[l1]); +free_domheap_page (pg); + } + } + pg =l2e_get_page (l2tab[l2]); +free_domheap_page (pg); + } + } + pg =l3e_get_page (d->arch.mm_arg_xlat_l3[l3]); +free_domheap_page (pg); + } + } +free_domheap_page (virt_to_page (d->arch.mm_arg_xlat_l3)); + } +#endif +free_xenheap_page (d->shared_info); }
@@ -931,55 +1030,131 @@ unsigned long hypercall_create_continuatfor ( i =0 ; *p !='\0' ; i++ ) mcs->call.args[i] =next_arg (p, args); +if (IS_COMPAT (current->domain) ) + { +for ( ; i <6 ; i++ ) + mcs->call.args[i] =0 ; + } }else { regs =guest_cpu_user_regs (); -#if defined(__i386__) regs->eax = op; + regs->eip -=2 ;/* re-execute 'syscall' / 'int 0x82' */ -if ( supervisor_mode_kernel ||hvm_guest (current) ) - regs->eip &= ~31 ;/* re-execute entire hypercall entry stub */ +#if defined(__x86_64__) +if ( !IS_COMPAT (current->domain) ) + { +for ( i =0 ; *p !='\0' ; i++ ) + { + arg =next_arg (p, args); +switch ( i ) + { +case 0 : regs->rdi = arg;break ; +case 1 : regs->rsi = arg;break ; +case 2 : regs->rdx = arg;break ; +case 3 : regs->r10 = arg;break ; +case 4 : regs->r8 = arg;break ; +case 5 : regs->r9 = arg;break ; + } + } + } else - regs->eip -=2 ;/* re-execute 'int 0x82' */ - -for ( i =0 ; *p !='\0' ; i++ ) +#endif { - arg =next_arg (p, args); -switch ( i ) +if ( supervisor_mode_kernel ||hvm_guest (current) ) + regs->eip &= ~31 ;/* re-execute entire hypercall entry stub */ + +for ( i =0 ; *p !='\0' ; i++ ) { -case 0 : regs->ebx = arg;break ; -case 1 : regs->ecx = arg;break ; -case 2 : regs->edx = arg;break ; -case 3 : regs->esi = arg;break ; -case 4 : regs->edi = arg;break ; -case 5 : regs->ebp = arg;break ; + arg =next_arg (p, args); +switch ( i ) + { +case 0 : regs->ebx = arg;break ; +case 1 : regs->ecx = arg;break ; +case 2 : regs->edx = arg;break ; +case 3 : regs->esi = arg;break ; +case 4 : regs->edi = arg;break ; +case 5 : regs->ebp = arg;break ; + } } } -#elif defined(__x86_64__) - regs->rax = op; - regs->rip -=2 ;/* re-execute 'syscall' */ + } -for ( i =0 ; *p !='\0' ; i++ ) +va_end (args); + +return op; +} + +#ifdef CONFIG_COMPAT +int hypercall_xlat_continuation (unsigned int mask, ...) +{ +int rc =0 ; +struct mc_state *mcs = &this_cpu (mc_state); +struct cpu_user_regs *regs =guest_cpu_user_regs (); +unsigned int i, cval =0 ; +unsigned long nval =0 ; +va_list args; + +va_start (args, mask); + +if (test_bit (_MCSF_in_multicall, &mcs->flags) ) + { +for ( i =0 ; i <6 ; ++i, mask >>=1 ) { - arg =next_arg (p, args); +if ( (mask &1 ) ) + { + nval = va_arg(args, unsigned long); + cval = va_arg(args, unsigned int); + } +if ( (mask &1 ) && mcs->call.args[i] == nval ) + { + ++rc; + } +else + { + cval = mcs->call.args[i]; +BUG_ON (mcs->call.args[i] != cval); + } + mcs->compat_call.args[i] = cval; + } + } +else + { +for ( i =0 ; i <6 ; ++i, mask >>=1 ) + { +unsigned long *reg; +switch ( i ) { -case 0 : regs->rdi = arg;break ; -case 1 : regs->rsi = arg;break ; -case 2 : regs->rdx = arg;break ; -case 3 : regs->r10 = arg;break ; -case 4 : regs->r8 = arg;break ; -case 5 : regs->r9 = arg;break ; +case 0 : reg = ®s->ebx;break ; +case 1 : reg = ®s->ecx;break ; +case 2 : reg = ®s->edx;break ; +case 3 : reg = ®s->esi;break ; +case 4 : reg = ®s->edi;break ; +case 5 : reg = ®s->ebp;break ; +default :BUG (); reg =NULL ;break ; + } +if ( (mask &1 ) ) + { + nval = va_arg(args, unsigned long); + cval = va_arg(args, unsigned int); + } +if ( (mask &1 ) && *reg == nval ) + { + *reg = cval; + ++rc; } +else +BUG_ON (*reg != (unsigned int )*reg); } -#endif }va_end (args); -return op; +return rc; } +#endif static void relinquish_memory (struct domain *d,struct list_head *list) {
xen/arch/x86/domain_build.c +4 -0
@@ -665,7 +665,11 @@ int construct_dom0(struct domain *d,l4e_from_paddr (__pa (d->arch.mm_perdomain_l3), __PAGE_HYPERVISOR); v->arch.guest_table =pagetable_from_paddr (__pa (l4start));if (IS_COMPAT (d) ) + { v->arch.guest_table_user = v->arch.guest_table; +if (setup_arg_xlat_area (d,0 , l4start) <0 ) +panic ("Not enough RAM for domain 0 hypercall argument translation.\n" ); + } l4tab +=l4_table_offset (dsi.v_start); mfn = alloc_spfn;
xen/arch/x86/mm.c +9 -4
@@ -1106,9 +1106,12 @@ static int alloc_l4_table(struct page_in pl4e[l4_table_offset (LINEAR_PT_VIRT_START )] =l4e_from_pfn (pfn, __PAGE_HYPERVISOR); pl4e[l4_table_offset (PERDOMAIN_VIRT_START )] = -l4e_from_page ( -virt_to_page (page_get_owner (page)->arch.mm_perdomain_l3), - __PAGE_HYPERVISOR); +l4e_from_page (virt_to_page (d->arch.mm_perdomain_l3), + __PAGE_HYPERVISOR); +if (IS_COMPAT (d) ) + pl4e[l4_table_offset (COMPAT_ARG_XLAT_VIRT_BASE )] = +l4e_from_page (virt_to_page (d->arch.mm_arg_xlat_l3), + __PAGE_HYPERVISOR);return 1 ;
@@ -2732,7 +2735,9 @@ int do_update_va_mapping(unsigned long vflush_tlb_mask (d->domain_dirty_cpumask);break ;default : -if (unlikely (get_user (vmask, (unsigned long *)bmap_ptr)) ) +if (unlikely (!IS_COMPAT (d) ? +get_user (vmask, (unsigned long *)bmap_ptr) : +get_user (vmask, (unsigned int *)bmap_ptr)) ) rc = -EFAULT ; pmask =vcpumask_to_pcpumask (d, vmask);flush_tlb_mask (pmask);
xen/arch/x86/x86_64/Makefile +1 -0
@@ -6,5 +6,6 @@ obj-y += traps.o ifeq ($(CONFIG_COMPAT),y) # extra dependencies entry.o: compat/entry.S +mm.o: compat/mm.c traps.o: compat/traps.c endif
xen/arch/x86/x86_64/compat/entry.S +0 -4
@@ -282,15 +282,11 @@ CFIX14: #define compat_mmu_update domain_crash_synchronous #define compat_set_gdt domain_crash_synchronous #define compat_platform_op domain_crash_synchronous -#define compat_update_descriptor domain_crash_synchronous -#define compat_memory_op domain_crash_synchronous #define compat_multicall domain_crash_synchronous -#define compat_update_va_mapping domain_crash_synchronous #define compat_set_timer_op domain_crash_synchronous #define compat_event_channel_op_compat domain_crash_synchronous #define compat_physdev_op_compat domain_crash_synchronous #define compat_grant_table_op domain_crash_synchronous -#define compat_update_va_mapping_otherdomain domain_crash_synchronous #define compat_vcpu_op domain_crash_synchronous #define compat_mmuext_op domain_crash_synchronous #define compat_acm_op domain_crash_synchronous
xen/arch/x86/x86_64/compat/mm.c new file +128 -0
128 lines not on this page · raw message
xen/arch/x86/x86_64/mm.c +3 -0
@@ -28,6 +28,7 @@#include <asm/page.h> #include <asm/flushtlb.h> #include <asm/fixmap.h> +#include <asm/hypercall.h> #include <asm/msr.h> #include <public/memory.h>
@@ -383,6 +384,8 @@ int check_descriptor(const struct domainreturn 0 ; } +#include "compat/mm.c" +/* * Local variables: * mode: C
xen/common/compat/Makefile +1 -0
@@ -1,4 +1,5 @@ obj-y += kernel.o +obj-y += memory.o obj-y += xlat.o # extra dependencies
xen/common/compat/memory.c new file +203 -0
203 lines not on this page · raw message
mfn_list));
+#define XLAT_translate_gpfn_list_HNDL_gpfn_list(_d_, _s_) \
+ do \
+ { \
+ set_xen_guest_handle((_d_)->gpfn_list, space - start_extent); \
+ for ( i = start_extent; i < end_extent; ++i ) \
+ { \+ compat_pfn_t pfn; \
+ if ( __copy_from_compat_offset(&pfn, (_s_)->gpfn_list, i, 1) ) \
+ return -EFAULT; \
+ *space++ = pfn; \
+ } \
+ } while (0)
+#define XLAT_translate_gpfn_list_HNDL_mfn_list(_d_, _s_) \
+ (_d_)->mfn_list = (_d_)->gpfn_list
+ XLAT_translate_gpfn_list(nat.xlat, &cmp.xlat);
+#undef XLAT_translate_gpfn_list_HNDL_mfn_list +#undef XLAT_translate_gpfn_list_HNDL_gpfn_list
+
+ if ( end_extent < cmp.xlat.nr_gpfns )
+ {
+ nat.xlat->nr_gpfns = end_extent;
+ ++split;
+ }
+
+ break;
+
+ default:
+ return compat_arch_memory_op(cmd, compat);
+ }
+
+ rc = do_memory_op(cmd, nat.hnd);
+ if ( rc < 0 )
+ return rc;
+
+ if ( hypercall_xlat_continuation(0x02, nat.hnd, compat) )
+ split = -1;
+
+ switch ( op )
+ {
+ case XENMEM_increase_reservation:
+ case XENMEM_decrease_reservation:
+ case XENMEM_populate_physmap:+ end_extent = split >= 0 ? rc : rc >> MEMOP_EXTENT_SHIFT;
+ if ( op != XENMEM_decrease_reservation &&
+ !guest_handle_is_null(nat.rsrv->extent_start) )
+ {
+ for ( ; start_extent < end_extent; ++start_extent )
+ {
+ compat_pfn_t pfn = nat.rsrv->extent_start.p[start_extent];
+
+ BUG_ON(pfn != nat.rsrv->extent_start.p[start_extent]);
+ if ( __copy_to_compat_offset(cmp.rsrv.extent_start, start_extent, &pfn, 1) )
+ {+ if ( split >= 0 )
+ {
+ rc = start_extent;
+ split = 0;
+ }
+ else
+ /*
+ * Short of being able to cancel the continuation, + * force it to restart here; eventually we shall + * get out of this state. + */
+ rc = (start_extent << MEMOP_EXTENT_SHIFT) | op;
+ break;
+ }
+ }
+ }
+ else
+ start_extent = end_extent;
+ break;
+
+ case XENMEM_exchange:
+ {
+ DEFINE_XEN_GUEST_HANDLE(compat_memory_exchange_t);
+ int order_delta;
+
+ BUG_ON(rc);
+ BUG_ON(end_extent < nat.xchg->nr_exchanged);
+ end_extent = nat.xchg->nr_exchanged;
+
+ order_delta = cmp.xchg.out.extent_order - cmp.xchg.in.extent_order;
+ if ( order_delta > 0 )
+ {
+ start_extent >>= order_delta;
+ BUG_ON(end_extent & ((1U << order_delta) - 1));
+ end_extent >>= order_delta;
+ }
+ else
+ {+ start_extent <<= -order_delta;
+ end_extent <<= -order_delta;
+ }
+
+ for ( ; start_extent < end_extent; ++start_extent )
+ {
+ compat_pfn_t pfn = nat.xchg->out.extent_start.p[start_extent];
+
+ BUG_ON(pfn != nat.xchg->out.extent_start.p[start_extent]); + /* Note that we ignore errors accessing the output extent list. */ + __copy_to_compat_offset(cmp.xchg.out.extent_start, start_extent, &pfn, 1);
+ }
+
+ cmp.xchg.nr_exchanged = nat.xchg->nr_exchanged;
+ if ( copy_field_to_guest(guest_handle_cast(compat, compat_memory_exchange_t),
+ &cmp.xchg, nr_exchanged) )
+ {
+ if ( split < 0 )
+ /* Cannot cancel the continuation... */
+ domain_crash_synchronous();
+ return -EFAULT;
+ }
+ break;
+ }
+
+ case XENMEM_maximum_ram_page: + case XENMEM_current_reservation: + case XENMEM_maximum_reservation:
+ break;
+
+ case XENMEM_translate_gpfn_list:
+ if ( split < 0 )
+ end_extent = rc >> MEMOP_EXTENT_SHIFT;
+ else
+ BUG_ON(rc);
+
+ for ( ; start_extent < end_extent; ++start_extent )
+ {
+ compat_pfn_t pfn = nat.xlat->mfn_list.p[start_extent];
+
+ BUG_ON(pfn != nat.xlat->mfn_list.p[start_extent]);
+ if ( __copy_to_compat_offset(cmp.xlat.mfn_list, start_extent, &pfn, 1) )
+ {+ if ( split < 0 )
+ /* Cannot cancel the continuation... */
+ domain_crash_synchronous();
+ return -EFAULT;
+ }
+ }
+ break;
+
+ default:
+ domain_crash_synchronous();
+ break;
+ }
+
+ cmd = op | (start_extent << MEMOP_EXTENT_SHIFT);
+ if ( split > 0 && hypercall_preempt_check() )
+ return hypercall_create_continuation(
+ __HYPERVISOR_memory_op, "ih", cmd, compat);
+ } while ( split > 0 );
+
+ return rc;
+}
xen/common/memory.c +8 -14
@@ -17,18 +17,12 @@#include <xen/shadow.h> #include <xen/iocap.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/errno.h> #include <asm/current.h> #include <asm/hardirq.h> #include <public/memory.h> -/* -* To allow safe resume of do_memory_op() after preemption, we need to know -* at what point in the page list to resume. For this purpose I steal the -* high-order bits of the @cmd parameter, which are otherwise unused and zero. -*/ -#define START_EXTENT_SHIFT 4/* cmd[:4] == start_extent */ - static long increase_reservation( struct domain *d,
@@ -236,7 +230,7 @@ translate_gpfn_list(return -EFAULT ;/* Is size too large for us to encode a continuation? */ -if ( op.nr_gpfns > (ULONG_MAX >>START_EXTENT_SHIFT ) ) +if ( op.nr_gpfns > (ULONG_MAX >>MEMOP_EXTENT_SHIFT ) )return -EINVAL ; if ( !guest_handle_okay(op.gpfn_list, op.nr_gpfns) ||
@@ -517,20 +511,20 @@ long do_memory_op(unsigned long cmd, XENstruct xen_memory_reservation reservation;domid_t domid; - op = cmd & ((1 <<START_EXTENT_SHIFT ) -1 ); + op = cmd &MEMOP_CMD_MASK ;switch ( op ) {case XENMEM_increase_reservation:case XENMEM_decrease_reservation:case XENMEM_populate_physmap: - start_extent = cmd >>START_EXTENT_SHIFT ; + start_extent = cmd >>MEMOP_EXTENT_SHIFT ;if (copy_from_guest (&reservation, arg,1 ) )return start_extent;/* Is size too large for us to encode a continuation? */ -if ( reservation.nr_extents > (ULONG_MAX >>START_EXTENT_SHIFT ) ) +if ( reservation.nr_extents > (ULONG_MAX >>MEMOP_EXTENT_SHIFT ) )return start_extent;if (unlikely (start_extent > reservation.nr_extents) )
@@ -594,7 +588,7 @@ long do_memory_op(unsigned long cmd, XENif ( preempted )return hypercall_create_continuation ( __HYPERVISOR_memory_op,"lh" , - op | (rc <<START_EXTENT_SHIFT ), arg); + op | (rc <<MEMOP_EXTENT_SHIFT ), arg);break ;
@@ -626,14 +620,14 @@ long do_memory_op(unsigned long cmd, XENbreak ;case XENMEM_translate_gpfn_list: - progress = cmd >>START_EXTENT_SHIFT ; + progress = cmd >>MEMOP_EXTENT_SHIFT ; rc =translate_gpfn_list (guest_handle_cast (arg, xen_translate_gpfn_list_t), &progress);if ( rc == -EAGAIN )return hypercall_create_continuation ( __HYPERVISOR_memory_op,"lh" , - op | (progress <<START_EXTENT_SHIFT ), arg); + op | (progress <<MEMOP_EXTENT_SHIFT ), arg);break ;default :
xen/include/asm-x86/config.h +21 -1
@@ -114,7 +114,7 @@ static inline void FORCE_CRASH(void)/* * Memory layout: * 0x0000000000000000 - 0x00007fffffffffff [128TB, 2^47 bytes, PML4:0-255] -* Guest-defined use. +* Guest-defined use (see below for compatibility mode guests). * 0x0000800000000000 - 0xffff7fffffffffff [16EB] * Inaccessible: current arch only supports 48-bit sign-extended VAs. * 0xffff800000000000 - 0xffff803fffffffff [256GB, 2^38 bytes, PML4:256]
@@ -147,6 +147,18 @@ static inline void FORCE_CRASH(void)* Reserved for future use. * 0xffff880000000000 - 0xffffffffffffffff [120TB, PML4:272-511] * Guest-defined use. +* +* Compatibility guest area layout: +* 0x0000000000000000 - 0x00000000f57fffff [3928MB, PML4:0] +* Guest-defined use. +* 0x0000000f58000000 - 0x00000000ffffffff [168MB, PML4:0] +* Read-only machine-to-phys translation table (GUEST ACCESSIBLE). +* 0x0000000000000000 - 0x00000000ffffffff [508GB, PML4:0] +* Unused. +* 0x0000008000000000 - 0x000000ffffffffff [512GB, 2^39 bytes, PML4:1] +* Hypercall argument translation area. +* 0x0000010000000000 - 0x00007fffffffffff [127TB, 2^46 bytes, PML4:2-255] +* Reserved for future use. */
@@ -216,6 +228,14 @@ static inline void FORCE_CRASH(void)#define COMPAT_L2_PAGETABLE_XEN_SLOTS \ (COMPAT_L2_PAGETABLE_LAST_XEN_SLOT - COMPAT_L2_PAGETABLE_FIRST_XEN_SLOT + 1) +#define COMPAT_ARG_XLAT_VIRT_BASE (1UL << ROOT_PAGETABLE_SHIFT) +#define COMPAT_ARG_XLAT_SHIFT 0 +#define COMPAT_ARG_XLAT_PAGES (1U << COMPAT_ARG_XLAT_SHIFT) +#define COMPAT_ARG_XLAT_SIZE (COMPAT_ARG_XLAT_PAGES << PAGE_SHIFT) +#define COMPAT_ARG_XLAT_VIRT_START (vcpu_id) \ + (COMPAT_ARG_XLAT_VIRT_BASE + ((unsigned long)(vcpu_id) << \ + (PAGE_SHIFT + COMPAT_ARG_XLAT_SHIFT + 1))) +#define PGT_base_page_table PGT_l4_page_table#define __HYPERVISOR_CS64 0xe008
xen/include/asm-x86/domain.h +4 -0
@@ -98,6 +98,10 @@ struct arch_domainstruct mapcache mapcache;#endif +#ifdef CONFIG_COMPAT +l3_pgentry_t *mm_arg_xlat_l3; +#endif +/* I/O-port admin-specified access capabilities. */ struct rangeset *ioport_caps;
xen/include/asm-x86/mm.h +10 -0
@@ -394,8 +394,18 @@ int __sync_lazy_execstate(void);/* Arch-specific portion of memory_op hypercall. */ long arch_memory_op (int op,XEN_GUEST_HANDLE (void ) arg);long subarch_memory_op (int op,XEN_GUEST_HANDLE (void ) arg); +#ifdef CONFIG_COMPAT +int compat_arch_memory_op (int op,XEN_GUEST_HANDLE (void )); +int compat_subarch_memory_op (int op,XEN_GUEST_HANDLE (void )); +#endif int steal_page (struct domain *d,struct page_info *page,unsigned int memflags); +#ifdef CONFIG_COMPAT +int setup_arg_xlat_area (struct domain *,unsigned int vcpu_id,l4_pgentry_t *); +#else +# define setup_arg_xlat_area (dom, vcpu_id, l4tab) 0 +#endif +#endif /* __ASM_X86_MM_H__ */
xen/include/xen/hypercall.h +18 -1
@@ -42,9 +42,17 @@ extern longdo_platform_op (XEN_GUEST_HANDLE (xen_platform_op_t ) u_xenpf_op); +/* +* To allow safe resume of do_memory_op() after preemption, we need to know +* at what point in the page list to resume. For this purpose I steal the +* high-order bits of the @cmd parameter, which are otherwise unused and zero. +*/ +#define MEMOP_EXTENT_SHIFT 4/* cmd[:4] == start_extent */ +#define MEMOP_CMD_MASK ((1 << MEMOP_EXTENT_SHIFT) - 1) +extern long do_memory_op ( -int cmd, +unsigned long cmd,XEN_GUEST_HANDLE (void ) arg); extern long
@@ -102,4 +110,13 @@ do_hvm_op( unsigned long op, XEN_GUEST_HANDLE(void) arg); +#ifdef CONFIG_COMPAT + +extern int +compat_memory_op ( +unsigned int cmd, +XEN_GUEST_HANDLE (void ) arg); + +#endif +#endif /* __XEN_HYPERCALL_H__ */
xen/include/xen/compat.h +2 -0
@@ -143,6 +143,8 @@ &((k compat_ ## n *)0)->f1.f2.f3) * 2] +int hypercall_xlat_continuation (unsigned int mask, ...); +/* In-place translation functons: */ struct start_info ;void xlat_start_info (struct start_info *,enum XLAT_start_info_console );
xen/include/xlat.lst +5 -0
@@ -4,3 +4,8 @@ ? dom0_vga_console_info xen.h ! start_info xen.h ? vcpu_time_info xen.h +! add_to_physmap memory.h +! memory_exchange memory.h +! memory_map memory.h +! memory_reservation memory.h +! translate_gpfn_list memory.h