CHOON.NET Forums - Xen-devel

[Xen-devel] how to configure a vm so as to use .../tools/blktap/drivers/block-qcow2.c (no replies)

hxkhust — Wed, 26 Dec 2012 12:06:21 +0800

hello,guys,

In order to use ...tools/blktap/drivers/block-qcow2.c I have tried many ways to set up a virtual machine including pvm/hvm, but I always failed.Under the situation that a hvm is configure with "tap:qcow2:...", qemu-dm is running and support the I/O process.But how to let block-qcow2.c in blktap running for image file write and read ?I need your help about the way on which a vm is created and a configure file example .
Thank you.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] Error : libxenlight state driver is not active (no replies)

Rohit Damkondwar — Wed, 26 Dec 2012 04:15:18 +0800

Hi all. I recently compiled xen 4.1.3 on Fedora 17(64 bit). The xen entry
appears in the grub. Inspite of booting Fedora, with xen hypervisor entry ,
when I start virt-manager, I get an error
" Internal Error : libxenlight state driver is not active "

Can anyone help me on this?

--
Rohit S Damkondwar
B.Tech Computer Engineering
CoEP
MyBlog [www.rohitsdamkondwar.wordpress.com]
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] It's said 'when the guest has PCI passthrough devices in use, operations like migration/save/restore are not possible.' where are the corresponding codes in xen? (no replies)

Oscar Ben — Wed, 26 Dec 2012 03:55:08 +0800

It's said 'when the guest has PCI passthrough devices in use, operations
like migration/save/restore are not possible.' where are the corresponding
codes in xen?

I'm wondering how xend/xenlight tells whether a guest has a pci passthu
device in use or not.

1. thank you in advance!
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] Using collectd: CPUFreq in dom0 (no replies)

Stefan Kuhne — Wed, 26 Dec 2012 03:01:29 +0800

Hello,

I've tried to get the CPUFreq plugin of collectd running in dom0.
But I mentioned that it isn't so easy to get a file in sysfs on the
rigth place.

I know that the value has to come from hypervisor and I've seen the code
in xenpm.

The only value I need is
"/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq" which would
create cpufreq.c.

Can anyone help me by giving me some hints?
I've read many websites and papers and coded many things.
I'm glade to get the sysfs file.

With "sysfs_create..." I've many trouble but "kobject_add" works fine.

Regards,
Stefan Kuhne

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] blktap2 and blktap2-new (no replies)

Vasiliy Tolstov — Tue, 25 Dec 2012 14:52:29 +0800

Hello. I found, that opensuse kernel-xen have two blktap2 modules. One
blktap2 and other blktap-new. What is difference and why needed two
modules (blktap2-new created by suse/opensuse patches)

xen10:~ # modinfo xen-blktap
filename:
/lib/modules/3.6.9-1-xen/kernel/drivers/xen/blktap2-new/xen-blktap.ko
alias: xen-backend:tap2
alias: devname:xen/blktap-2/control
license: Dual BSD/GPL
srcversion: A4659328DBBF5A422315CA5
depends:
intree: Y
vermagic: 3.6.9-1-xen SMP mod_unload modversions Xen
xen10:~ # modinfo blktap2
filename: /lib/modules/3.6.9-1-xen/kernel/drivers/xen/blktap2/blktap2.ko
alias: xen-backend:tap2
alias: devname:xen/blktap-2/control
license: Dual BSD/GPL
srcversion: 8C21A63E6BCEEFFAD2B0DDA
depends: blkback-pagemap
intree: Y
vermagic: 3.6.9-1-xen SMP mod_unload modversions Xen

--
Vasiliy Tolstov,
Clodo.ru
e-mail: v.tolstov@selfip.ru
jabber: vase@selfip.ru

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH v4 00/10] Nested VMX: Add virtual EPT & VPID support to L1 VMM (6 replies)

Xiantao Zhang — Mon, 24 Dec 2012 22:31:45 +0800

From: Zhang Xiantao

With virtual EPT support, L1 hyerpvisor can use EPT hardware for L2 guest's memory virtualization.
In this way, L2 guest's performance can be improved sharply.
According to our testing, some benchmarks can show > 5x performance gain.

Changes from v1:
Update the patches according to Tim's comments.
1. Patch 03: Enhance the virtual EPT's walker logic.
2. Patch 04: Add a new field in struct p2m_domain, and use it to store
EPT-specific data. For host p2m, it saves L1 VMM's EPT data,
and for nested p2m, it saves nested EPT's data 3. Patch 07: strictly check host's p2m access type.
4. Other patches: some whitespace mangling fixes.

Changes form v2:
Addressed comments from Jan and Jun:
1. Add Acked-by message for reviewed patches by Tim.
2. Fixed one whitespace mangling issue in PATCH 08 3. Add some comments to describe the meaning of
the return value of hvm_hap_nested_page_fault
in PATCH 05.
4. Add the logic for handling default case of two switch
statements.

Changes v3:
1. Re-check all patches' whitespace mangling issue.

2. Addressed Jan's comments in Patch08 and Patch09 that once return X86EMUL_EXCEPTION, the callee
should be responsible for handling the execption before its return.

3. Addressed Tim's comments in Patch03 and Patch04 and Patch07:
Patch03: If host doesn't support exec-only capability, we shoudln't expost this feature to L1 VMM.
Once map guest's EPT table error, inject an EPT misconfiguration errot to L1.
Patch04: Re-organize p2m's and nested p2m's structure {init/teardown} logic.
Patch07: Initialize p2ma_21 -> p2m_access_rwx, so not to change SVM's behavior.

Zhang Xiantao (10):
nestedhap: Change hostcr3 and p2m->cr3 to meaningful words
nestedhap: Change nested p2m's walker to vendor-specific
nested_ept: Implement guest ept's walker
EPT: Make ept data structure or operations neutral
nEPT: Try to enable EPT paging for L2 guest.
nEPT: Sync PDPTR fields if L2 guest in PAE paging mode
nEPT: Use minimal permission for nested p2m.
nEPT: handle invept instruction from L1 VMM
nVMX: virutalize VPID capability to nested VMM.
nEPT: expose EPT & VPID capablities to L1 VMM

xen/arch/x86/hvm/hvm.c | 7 +-
xen/arch/x86/hvm/svm/nestedsvm.c | 31 ++++
xen/arch/x86/hvm/svm/svm.c | 3 +-
xen/arch/x86/hvm/vmx/vmcs.c | 8 +-
xen/arch/x86/hvm/vmx/vmx.c | 91 ++++------
xen/arch/x86/hvm/vmx/vvmx.c | 208 ++++++++++++++++++++--
xen/arch/x86/mm/guest_walk.c | 16 +-
xen/arch/x86/mm/hap/Makefile | 1 +
xen/arch/x86/mm/hap/nested_ept.c | 298 +++++++++++++++++++++++++++++++
xen/arch/x86/mm/hap/nested_hap.c | 96 ++++++-----
xen/arch/x86/mm/mm-locks.h | 2 +-
xen/arch/x86/mm/p2m-ept.c | 104 +++++++++---
xen/arch/x86/mm/p2m.c | 159 +++++++++++------
xen/include/asm-x86/guest_pt.h | 8 +
xen/include/asm-x86/hvm/hvm.h | 9 +-
xen/include/asm-x86/hvm/nestedhvm.h | 1 +
xen/include/asm-x86/hvm/svm/nestedsvm.h | 3 +
xen/include/asm-x86/hvm/vmx/vmcs.h | 24 ++--
xen/include/asm-x86/hvm/vmx/vmx.h | 41 ++++-
xen/include/asm-x86/hvm/vmx/vvmx.h | 28 +++-
xen/include/asm-x86/p2m.h | 20 ++-
21 files changed, 932 insertions(+), 226 deletions(-)
create mode 100644 xen/arch/x86/mm/hap/nested_ept.c

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH v4 03/10] nested_ept: Implement guest ept's walker (no replies)

Xiantao Zhang — Mon, 24 Dec 2012 22:31:40 +0800

From: Zhang Xiantao

Implment guest EPT PT walker, some logic is based on shadow's
ia32e PT walker. During the PT walking, if the target pages are
not in memory, use RETRY mechanism and get a chance to let the
target page back.

Signed-off-by: Zhang Xiantao
---
xen/arch/x86/hvm/hvm.c | 1 +
xen/arch/x86/hvm/vmx/vvmx.c | 42 +++++-
xen/arch/x86/mm/guest_walk.c | 16 ++-
xen/arch/x86/mm/hap/Makefile | 1 +
xen/arch/x86/mm/hap/nested_ept.c | 287 +++++++++++++++++++++++++++++++++++
xen/arch/x86/mm/hap/nested_hap.c | 2 +-
xen/include/asm-x86/guest_pt.h | 8 +
xen/include/asm-x86/hvm/nestedhvm.h | 1 +
xen/include/asm-x86/hvm/vmx/vmcs.h | 1 +
xen/include/asm-x86/hvm/vmx/vmx.h | 31 ++++
xen/include/asm-x86/hvm/vmx/vvmx.h | 13 ++
11 files changed, 394 insertions(+), 9 deletions(-)
create mode 100644 xen/arch/x86/mm/hap/nested_ept.c

diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c
index f63ee52..bd7314f 100644
--- a/xen/arch/x86/hvm/hvm.c
+++ b/xen/arch/x86/hvm/hvm.c
@@ -1324,6 +1324,7 @@ int hvm_hap_nested_page_fault(paddr_t gpa,
access_r, access_w, access_x);
switch (rv) {
case NESTEDHVM_PAGEFAULT_DONE:
+ case NESTEDHVM_PAGEFAULT_RETRY:
return 1;
case NESTEDHVM_PAGEFAULT_L1_ERROR:
/* An error occured while translating gpa from
diff --git a/xen/arch/x86/hvm/vmx/vvmx.c b/xen/arch/x86/hvm/vmx/vvmx.c
index 53f6a4d..1d3090d 100644
--- a/xen/arch/x86/hvm/vmx/vvmx.c
+++ b/xen/arch/x86/hvm/vmx/vvmx.c
@@ -939,9 +939,18 @@ static void sync_vvmcs_ro(struct vcpu *v)
{
int i;
struct nestedvcpu *nvcpu = &vcpu_nestedhvm(v);
+ struct nestedvmx *nvmx = &vcpu_2_nvmx(v);
+ void *vvmcs = nvcpu->nv_vvmcx;

for ( i = 0; i < ARRAY_SIZE(vmcs_ro_field); i++ )
shadow_to_vvmcs(nvcpu->nv_vvmcx, vmcs_ro_field);
+
+ /* Adjust exit_reason/exit_qualifciation for violation case */
+ if ( __get_vvmcs(vvmcs, VM_EXIT_REASON) == EXIT_REASON_EPT_VIOLATION )
+ {
+ __set_vvmcs(vvmcs, EXIT_QUALIFICATION, nvmx->ept_exit.exit_qual);
+ __set_vvmcs(vvmcs, VM_EXIT_REASON, nvmx->ept_exit.exit_reason);
+ }
}

static void load_vvmcs_host_state(struct vcpu *v)
@@ -1488,8 +1497,37 @@ nvmx_hap_walk_L1_p2m(struct vcpu *v, paddr_t L2_gpa, paddr_t *L1_gpa,
unsigned int *page_order,
bool_t access_r, bool_t access_w, bool_t access_x)
{
- /*TODO:*/
- return 0;
+ int rc;
+ unsigned long gfn;
+ uint64_t exit_qual = __vmread(EXIT_QUALIFICATION);
+ uint32_t exit_reason = EXIT_REASON_EPT_VIOLATION;
+ uint32_t rwx_rights = (access_x << 2) | (access_w << 1) | access_r;
+ struct nestedvmx *nvmx = &vcpu_2_nvmx(v);
+
+ rc = nept_translate_l2ga(v, L2_gpa, page_order, rwx_rights, &gfn,
+ &exit_qual, &exit_reason);
+ switch ( rc )
+ {
+ case EPT_TRANSLATE_SUCCEED:
+ *L1_gpa = (gfn << PAGE_SHIFT) + (L2_gpa & ~PAGE_MASK);
+ rc = NESTEDHVM_PAGEFAULT_DONE;
+ break;
+ case EPT_TRANSLATE_VIOLATION:
+ case EPT_TRANSLATE_MISCONFIG:
+ rc = NESTEDHVM_PAGEFAULT_INJECT;
+ nvmx->ept_exit.exit_reason = exit_reason;
+ nvmx->ept_exit.exit_qual = exit_qual;
+ break;
+ case EPT_TRANSLATE_RETRY:
+ rc = NESTEDHVM_PAGEFAULT_RETRY;
+ break;
+ default:
+ gdprintk(XENLOG_ERR, "GUEST EPT translation error!:%d\n", rc);
+ BUG();
+ break;
+ }
+
+ return rc;
}

void nvmx_idtv_handling(void)
diff --git a/xen/arch/x86/mm/guest_walk.c b/xen/arch/x86/mm/guest_walk.c
index 0f08fb0..1c165c6 100644
--- a/xen/arch/x86/mm/guest_walk.c
+++ b/xen/arch/x86/mm/guest_walk.c
@@ -88,18 +88,19 @@ static uint32_t set_ad_bits(void *guest_p, void *walk_p, int set_dirty)

/* If the map is non-NULL, we leave this function having
* acquired an extra ref on mfn_to_page(*mfn) */
-static inline void *map_domain_gfn(struct p2m_domain *p2m,
- gfn_t gfn,
+void *map_domain_gfn(struct p2m_domain *p2m,
+ gfn_t gfn,
mfn_t *mfn,
p2m_type_t *p2mt,
- uint32_t *rc)
+ p2m_query_t q,
+ uint32_t *rc)
{
struct page_info *page;
void *map;

/* Translate the gfn, unsharing if shared */
page = get_page_from_gfn_p2m(p2m->domain, p2m, gfn_x(gfn), p2mt, NULL,
- P2M_ALLOC | P2M_UNSHARE);
+ q);
if ( p2m_is_paging(*p2mt) )
{
ASSERT(!p2m_is_nestedp2m(p2m));
@@ -128,7 +129,6 @@ static inline void *map_domain_gfn(struct p2m_domain *p2m,
return map;
}

-
/* Walk the guest pagetables, after the manner of a hardware walker. */
/* Because the walk is essentially random, it can cause a deadlock
* warning in the p2m locking code. Highly unlikely this is an actual
@@ -149,6 +149,7 @@ guest_walk_tables(struct vcpu *v, struct p2m_domain *p2m,
uint32_t gflags, mflags, iflags, rc = 0;
int smep;
bool_t pse1G = 0, pse2M = 0;
+ p2m_query_t qt = P2M_ALLOC | P2M_UNSHARE;

perfc_incr(guest_walk);
memset(gw, 0, sizeof(*gw));
@@ -188,7 +189,8 @@ guest_walk_tables(struct vcpu *v, struct p2m_domain *p2m,
l3p = map_domain_gfn(p2m,
guest_l4e_get_gfn(gw->l4e),
&gw->l3mfn,
- &p2mt,
+ &p2mt,
+ qt,
&rc);
if(l3p == NULL)
goto out;
@@ -249,6 +251,7 @@ guest_walk_tables(struct vcpu *v, struct p2m_domain *p2m,
guest_l3e_get_gfn(gw->l3e),
&gw->l2mfn,
&p2mt,
+ qt,
&rc);
if(l2p == NULL)
goto out;
@@ -322,6 +325,7 @@ guest_walk_tables(struct vcpu *v, struct p2m_domain *p2m,
guest_l2e_get_gfn(gw->l2e),
&gw->l1mfn,
&p2mt,
+ qt,
&rc);
if(l1p == NULL)
goto out;
diff --git a/xen/arch/x86/mm/hap/Makefile b/xen/arch/x86/mm/hap/Makefile
index 80a6bec..68f2bb5 100644
--- a/xen/arch/x86/mm/hap/Makefile
+++ b/xen/arch/x86/mm/hap/Makefile
@@ -3,6 +3,7 @@ obj-y += guest_walk_2level.o
obj-y += guest_walk_3level.o
obj-$(x86_64) += guest_walk_4level.o
obj-y += nested_hap.o
+obj-y += nested_ept.o

guest_walk_%level.o: guest_walk.c Makefile
$(CC) $(CFLAGS) -DGUEST_PAGING_LEVELS=$* -c $< -o $@
diff --git a/xen/arch/x86/mm/hap/nested_ept.c b/xen/arch/x86/mm/hap/nested_ept.c
new file mode 100644
index 0000000..1463d81
--- /dev/null
+++ b/xen/arch/x86/mm/hap/nested_ept.c
@@ -0,0 +1,287 @@
+/*
+ * nested_ept.c: Handling virtulized EPT for guest in nested case.
+ *
+ * Copyright (c) 2012, Intel Corporation
+ * Xiantao Zhang
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ */
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#include "private.h"
+
+#include
+#include
+
+/* EPT always use 4-level paging structure */
+#define GUEST_PAGING_LEVELS 4
+#include
+
+/* Must reserved bits in all level entries */
+#define EPT_MUST_RSV_BITS (((1ull << PADDR_BITS) -1) & \
+ ~((1ull << paddr_bits) - 1))
+
+/*
+ *TODO: Just leave it as 0 here for compile pass, will
+ * define real capabilities in the subsequent patches.
+ */
+#define NEPT_VPID_CAP_BITS 0
+
+
+#define NEPT_1G_ENTRY_FLAG (1 << 11)
+#define NEPT_2M_ENTRY_FLAG (1 << 10)
+#define NEPT_4K_ENTRY_FLAG (1 << 9)
+
+bool_t nept_sp_entry(ept_entry_t e)
+{
+ return !!(e.sp);
+}
+
+static bool_t nept_rsv_bits_check(ept_entry_t e, uint32_t level)
+{
+ uint64_t rsv_bits = EPT_MUST_RSV_BITS;
+
+ switch ( level )
+ {
+ case 1:
+ break;
+ case 2 ... 3:
+ if ( nept_sp_entry(e) )
+ rsv_bits |= ((1ull << (9 * (level -1 ))) -1) << PAGE_SHIFT;
+ else
+ rsv_bits |= EPTE_EMT_MASK | EPTE_IGMT_MASK;
+ break;
+ case 4:
+ rsv_bits |= EPTE_EMT_MASK | EPTE_IGMT_MASK | EPTE_SUPER_PAGE_MASK;
+ break;
+ default:
+ gdprintk(XENLOG_ERR,"Unsupported EPT paging level: %d\n", level);
+ BUG();
+ break;
+ }
+ return !!(e.epte & rsv_bits);
+}
+
+/* EMT checking*/
+static bool_t nept_emt_bits_check(ept_entry_t e, uint32_t level)
+{
+ if ( e.sp || level == 1 )
+ {
+ if ( e.emt == EPT_EMT_RSV0 || e.emt == EPT_EMT_RSV1 ||
+ e.emt == EPT_EMT_RSV2 )
+ return 1;
+ }
+ return 0;
+}
+
+static bool_t nept_permission_check(uint32_t rwx_acc, uint32_t rwx_bits)
+{
+ return !(EPTE_RWX_MASK & rwx_acc & ~rwx_bits);
+}
+
+/* nept's non-present check */
+static bool_t nept_non_present_check(ept_entry_t e)
+{
+ if ( e.epte & EPTE_RWX_MASK )
+ return 0;
+ return 1;
+}
+
+uint64_t nept_get_ept_vpid_cap(void)
+{
+ uint64_t caps = NEPT_VPID_CAP_BITS;
+
+ if ( !cpu_has_vmx_ept_exec_only_supported )
+ caps &= ~VMX_EPT_EXEC_ONLY_SUPPORTED;
+ return caps;
+}
+
+static bool_t nept_rwx_bits_check(ept_entry_t e)
+{
+ /*write only or write/execute only*/
+ uint8_t rwx_bits = e.epte & EPTE_RWX_MASK;
+
+ if ( rwx_bits == ept_access_w || rwx_bits == ept_access_wx )
+ return 1;
+
+ if ( rwx_bits == ept_access_x && !(nept_get_ept_vpid_cap() &
+ VMX_EPT_EXEC_ONLY_SUPPORTED) )
+ return 1;
+
+ return 0;
+}
+
+/* nept's misconfiguration check */
+static bool_t nept_misconfiguration_check(ept_entry_t e, uint32_t level)
+{
+ return (nept_rsv_bits_check(e, level) ||
+ nept_emt_bits_check(e, level) ||
+ nept_rwx_bits_check(e));
+}
+
+static int ept_lvl_table_offset(unsigned long gpa, int lvl)
+{
+ return (gpa >>(EPT_L4_PAGETABLE_SHIFT -(4 - lvl) * 9)) &
+ (EPT_PAGETABLE_ENTRIES -1 );
+}
+
+static uint32_t
+nept_walk_tables(struct vcpu *v, unsigned long l2ga, ept_walk_t *gw)
+{
+ int lvl;
+ p2m_type_t p2mt;
+ uint32_t rc = 0, ret = 0, gflags;
+ struct domain *d = v->domain;
+ struct p2m_domain *p2m = d->arch.p2m;
+ gfn_t base_gfn = _gfn(nhvm_vcpu_p2m_base(v) >> PAGE_SHIFT);
+ mfn_t lxmfn;
+ ept_entry_t *lxp = NULL;
+
+ memset(gw, 0, sizeof(*gw));
+
+ for (lvl = 4; lvl > 0; lvl--)
+ {
+ lxp = map_domain_gfn(p2m, base_gfn, &lxmfn, &p2mt, P2M_ALLOC, &rc);
+ if ( !lxp )
+ goto map_err;
+ gw->lxe[lvl] = lxp[ept_lvl_table_offset(l2ga, lvl)];
+ unmap_domain_page(lxp);
+ put_page(mfn_to_page(mfn_x(lxmfn)));
+
+ if ( nept_non_present_check(gw->lxe[lvl]) )
+ goto non_present;
+
+ if ( nept_misconfiguration_check(gw->lxe[lvl], lvl) )
+ goto misconfig_err;
+
+ if ( (lvl == 2 || lvl == 3) && nept_sp_entry(gw->lxe[lvl]) )
+ {
+ /* Generate a fake l1 table entry so callers don't all
+ * have to understand superpages. */
+ unsigned long gfn_lvl_mask = (1ull << ((lvl - 1) * 9)) - 1;
+ gfn_t start = _gfn(gw->lxe[lvl].mfn);
+ /* Increment the pfn by the right number of 4k pages. */
+ start = _gfn((gfn_x(start) & ~gfn_lvl_mask) +
+ ((l2ga >> PAGE_SHIFT) & gfn_lvl_mask));
+ gflags = (gw->lxe[lvl].epte & EPTE_FLAG_MASK) |
+ (lvl == 3 ? NEPT_1G_ENTRY_FLAG: NEPT_2M_ENTRY_FLAG);
+ gw->lxe[0].epte = (gfn_x(start) << PAGE_SHIFT) | gflags;
+ goto done;
+ }
+ if ( lvl > 1 )
+ base_gfn = _gfn(gw->lxe[lvl].mfn);
+ }
+
+ /* If this is not a super entry, we can reach here. */
+ gflags = (gw->lxe[1].epte & EPTE_FLAG_MASK) | NEPT_4K_ENTRY_FLAG;
+ gw->lxe[0].epte = (gw->lxe[1].epte & PAGE_MASK) | gflags;
+
+done:
+ ret = EPT_TRANSLATE_SUCCEED;
+ goto out;
+
+map_err:
+ if ( rc == _PAGE_PAGED )
+ {
+ ret = EPT_TRANSLATE_RETRY;
+ goto out;
+ }
+ /* fall through to misconfig error */
+misconfig_err:
+ ret = EPT_TRANSLATE_MISCONFIG;
+ goto out;
+
+non_present:
+ ret = EPT_TRANSLATE_VIOLATION;
+ /* fall through. */
+out:
+ return ret;
+}
+
+/* Translate a L2 guest address to L1 gpa via L1 EPT paging structure */
+
+int nept_translate_l2ga(struct vcpu *v, paddr_t l2ga,
+ unsigned int *page_order, uint32_t rwx_acc,
+ unsigned long *l1gfn, uint64_t *exit_qual,
+ uint32_t *exit_reason)
+{
+ uint32_t rc, rwx_bits = 0;
+ ept_walk_t gw;
+ rwx_acc &= EPTE_RWX_MASK;
+
+ *l1gfn = INVALID_GFN;
+
+ rc = nept_walk_tables(v, l2ga, &gw);
+ switch ( rc )
+ {
+ case EPT_TRANSLATE_SUCCEED:
+ if ( likely(gw.lxe[0].epte & NEPT_2M_ENTRY_FLAG) )
+ {
+ rwx_bits = gw.lxe[4].epte & gw.lxe[3].epte & gw.lxe[2].epte &
+ EPTE_RWX_MASK;
+ *page_order = 9;
+ }
+ else if ( gw.lxe[0].epte & NEPT_4K_ENTRY_FLAG )
+ {
+ rwx_bits = gw.lxe[4].epte & gw.lxe[3].epte & gw.lxe[2].epte &
+ gw.lxe[1].epte & EPTE_RWX_MASK;
+ *page_order = 0;
+ }
+ else if ( gw.lxe[0].epte & NEPT_1G_ENTRY_FLAG )
+ {
+ rwx_bits = gw.lxe[4].epte & gw.lxe[3].epte & EPTE_RWX_MASK;
+ *page_order = 18;
+ }
+ else
+ {
+ gdprintk(XENLOG_ERR, "Uncorrect l1 entry!\n");
+ BUG();
+ }
+ if ( nept_permission_check(rwx_acc, rwx_bits) )
+ {
+ *l1gfn = gw.lxe[0].mfn;
+ break;
+ }
+ rc = EPT_TRANSLATE_VIOLATION;
+ /* Fall through to EPT violation if permission check fails. */
+ case EPT_TRANSLATE_VIOLATION:
+ *exit_qual = (*exit_qual & 0xffffffc0) | (rwx_bits << 3) | rwx_acc;
+ *exit_reason = EXIT_REASON_EPT_VIOLATION;
+ break;
+
+ case EPT_TRANSLATE_MISCONFIG:
+ rc = EPT_TRANSLATE_MISCONFIG;
+ *exit_qual = 0;
+ *exit_reason = EXIT_REASON_EPT_MISCONFIG;
+ break;
+ case EPT_TRANSLATE_RETRY:
+ break;
+ default:
+ gdprintk(XENLOG_ERR, "Unsupported ept translation type!:%d\n", rc);
+ BUG();
+ break;
+ }
+ return rc;
+}
diff --git a/xen/arch/x86/mm/hap/nested_hap.c b/xen/arch/x86/mm/hap/nested_hap.c
index 8787c91..6d1264b 100644
--- a/xen/arch/x86/mm/hap/nested_hap.c
+++ b/xen/arch/x86/mm/hap/nested_hap.c
@@ -217,7 +217,7 @@ nestedhvm_hap_nested_page_fault(struct vcpu *v, paddr_t *L2_gpa,
/* let caller to handle these two cases */
switch (rv) {
case NESTEDHVM_PAGEFAULT_INJECT:
- return rv;
+ case NESTEDHVM_PAGEFAULT_RETRY:
case NESTEDHVM_PAGEFAULT_L1_ERROR:
return rv;
case NESTEDHVM_PAGEFAULT_DONE:
diff --git a/xen/include/asm-x86/guest_pt.h b/xen/include/asm-x86/guest_pt.h
index 4e1dda0..db8a0b6 100644
--- a/xen/include/asm-x86/guest_pt.h
+++ b/xen/include/asm-x86/guest_pt.h
@@ -315,6 +315,14 @@ guest_walk_to_page_order(walk_t *gw)
#define GPT_RENAME2(_n, _l) _n ## _ ## _l ## _levels
#define GPT_RENAME(_n, _l) GPT_RENAME2(_n, _l)
#define guest_walk_tables GPT_RENAME(guest_walk_tables, GUEST_PAGING_LEVELS)
+#define map_domain_gfn GPT_RENAME(map_domain_gfn, GUEST_PAGING_LEVELS)
+
+extern void *map_domain_gfn(struct p2m_domain *p2m,
+ gfn_t gfn,
+ mfn_t *mfn,
+ p2m_type_t *p2mt,
+ p2m_query_t q,
+ uint32_t *rc);

extern uint32_t
guest_walk_tables(struct vcpu *v, struct p2m_domain *p2m, unsigned long va,
diff --git a/xen/include/asm-x86/hvm/nestedhvm.h b/xen/include/asm-x86/hvm/nestedhvm.h
index 91fde0b..649c511 100644
--- a/xen/include/asm-x86/hvm/nestedhvm.h
+++ b/xen/include/asm-x86/hvm/nestedhvm.h
@@ -52,6 +52,7 @@ bool_t nestedhvm_vcpu_in_guestmode(struct vcpu *v);
#define NESTEDHVM_PAGEFAULT_L1_ERROR 2
#define NESTEDHVM_PAGEFAULT_L0_ERROR 3
#define NESTEDHVM_PAGEFAULT_MMIO 4
+#define NESTEDHVM_PAGEFAULT_RETRY 5
int nestedhvm_hap_nested_page_fault(struct vcpu *v, paddr_t *L2_gpa,
bool_t access_r, bool_t access_w, bool_t access_x);

diff --git a/xen/include/asm-x86/hvm/vmx/vmcs.h b/xen/include/asm-x86/hvm/vmx/vmcs.h
index ef2c9c9..9a728b6 100644
--- a/xen/include/asm-x86/hvm/vmx/vmcs.h
+++ b/xen/include/asm-x86/hvm/vmx/vmcs.h
@@ -194,6 +194,7 @@ extern u32 vmx_secondary_exec_control;

extern bool_t cpu_has_vmx_ins_outs_instr_info;

+#define VMX_EPT_EXEC_ONLY_SUPPORTED 0x00000001
#define VMX_EPT_WALK_LENGTH_4_SUPPORTED 0x00000040
#define VMX_EPT_MEMORY_TYPE_UC 0x00000100
#define VMX_EPT_MEMORY_TYPE_WB 0x00004000
diff --git a/xen/include/asm-x86/hvm/vmx/vmx.h b/xen/include/asm-x86/hvm/vmx/vmx.h
index aa5b080..c73946f 100644
--- a/xen/include/asm-x86/hvm/vmx/vmx.h
+++ b/xen/include/asm-x86/hvm/vmx/vmx.h
@@ -51,6 +51,22 @@ typedef union {
u64 epte;
} ept_entry_t;

+typedef struct {
+ /*use lxe[0] to save result */
+ ept_entry_t lxe[5];
+} ept_walk_t;
+
+typedef enum {
+ ept_access_n = 0, /* No access permissions allowed */
+ ept_access_r = 1, /* Read only */
+ ept_access_w = 2, /* Write only */
+ ept_access_rw = 3, /* Read & Write */
+ ept_access_x = 4, /* Exec Only */
+ ept_access_rx = 5, /* Read & Exec */
+ ept_access_wx = 6, /* Write & Exec*/
+ ept_access_all = 7, /* Full permissions */
+} ept_access_t;
+
#define EPT_TABLE_ORDER 9
#define EPTE_SUPER_PAGE_MASK 0x80
#define EPTE_MFN_MASK 0xffffffffff000ULL
@@ -60,6 +76,17 @@ typedef union {
#define EPTE_AVAIL1_SHIFT 8
#define EPTE_EMT_SHIFT 3
#define EPTE_IGMT_SHIFT 6
+#define EPTE_RWX_MASK 0x7
+#define EPTE_FLAG_MASK 0x7f
+
+#define EPT_EMT_UC 0
+#define EPT_EMT_WC 1
+#define EPT_EMT_RSV0 2
+#define EPT_EMT_RSV1 3
+#define EPT_EMT_WT 4
+#define EPT_EMT_WP 5
+#define EPT_EMT_WB 6
+#define EPT_EMT_RSV2 7

void vmx_asm_vmexit_handler(struct cpu_user_regs);
void vmx_asm_do_vmentry(void);
@@ -191,6 +218,9 @@ void vmx_update_secondary_exec_control(struct vcpu *v);

extern u64 vmx_ept_vpid_cap;

+#define cpu_has_vmx_ept_exec_only_supported \
+ (vmx_ept_vpid_cap & VMX_EPT_EXEC_ONLY_SUPPORTED)
+
#define cpu_has_vmx_ept_wl4_supported \
(vmx_ept_vpid_cap & VMX_EPT_WALK_LENGTH_4_SUPPORTED)
#define cpu_has_vmx_ept_mt_uc \
@@ -419,6 +449,7 @@ void update_guest_eip(void);
#define _EPT_GLA_FAULT 8
#define EPT_GLA_FAULT (1UL<<_EPT_GLA_FAULT)

+#define EPT_L4_PAGETABLE_SHIFT 39
#define EPT_PAGETABLE_ENTRIES 512

#endif /* __ASM_X86_HVM_VMX_VMX_H__ */
diff --git a/xen/include/asm-x86/hvm/vmx/vvmx.h b/xen/include/asm-x86/hvm/vmx/vvmx.h
index 422f006..97554bf 100644
--- a/xen/include/asm-x86/hvm/vmx/vvmx.h
+++ b/xen/include/asm-x86/hvm/vmx/vvmx.h
@@ -32,6 +32,10 @@ struct nestedvmx {
unsigned long intr_info;
u32 error_code;
} intr;
+ struct {
+ uint32_t exit_reason;
+ uint32_t exit_qual;
+ } ept_exit;
};

#define vcpu_2_nvmx(v) (vcpu_nestedhvm(v).u.nvmx)
@@ -109,6 +113,11 @@ void nvmx_domain_relinquish_resources(struct domain *d);
int nvmx_handle_vmxon(struct cpu_user_regs *regs);
int nvmx_handle_vmxoff(struct cpu_user_regs *regs);

+#define EPT_TRANSLATE_SUCCEED 0
+#define EPT_TRANSLATE_VIOLATION 1
+#define EPT_TRANSLATE_MISCONFIG 2
+#define EPT_TRANSLATE_RETRY 3
+
int
nvmx_hap_walk_L1_p2m(struct vcpu *v, paddr_t L2_gpa, paddr_t *L1_gpa,
unsigned int *page_order,
@@ -192,5 +201,9 @@ u64 nvmx_get_tsc_offset(struct vcpu *v);
int nvmx_n2_vmexit_handler(struct cpu_user_regs *regs,
unsigned int exit_reason);

+int nept_translate_l2ga(struct vcpu *v, paddr_t l2ga,
+ unsigned int *page_order, uint32_t rwx_acc,
+ unsigned long *l1gfn, uint64_t *exit_qual,
+ uint32_t *exit_reason);
#endif /* __ASM_X86_HVM_VVMX_H__ */

--
1.7.1

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH v4 04/10] EPT: Make ept data structure or operations neutral (no replies)

Xiantao Zhang — Mon, 24 Dec 2012 22:31:38 +0800

From: Zhang Xiantao

Share the current EPT logic with nested EPT case, so
make the related data structure or operations netural
to comment EPT and nested EPT.

Signed-off-by: Zhang Xiantao
---
xen/arch/x86/hvm/vmx/vmcs.c | 8 ++-
xen/arch/x86/hvm/vmx/vmx.c | 53 +-------------
xen/arch/x86/mm/p2m-ept.c | 104 ++++++++++++++++++++++------
xen/arch/x86/mm/p2m.c | 132 +++++++++++++++++++++++++-----------
xen/include/asm-x86/hvm/vmx/vmcs.h | 23 +++---
xen/include/asm-x86/hvm/vmx/vmx.h | 10 ++-
xen/include/asm-x86/p2m.h | 4 +
7 files changed, 208 insertions(+), 126 deletions(-)

diff --git a/xen/arch/x86/hvm/vmx/vmcs.c b/xen/arch/x86/hvm/vmx/vmcs.c
index 9adc7a4..de22e03 100644
--- a/xen/arch/x86/hvm/vmx/vmcs.c
+++ b/xen/arch/x86/hvm/vmx/vmcs.c
@@ -942,7 +942,13 @@ static int construct_vmcs(struct vcpu *v)
}

if ( paging_mode_hap(d) )
- __vmwrite(EPT_POINTER, d->arch.hvm_domain.vmx.ept_control.eptp);
+ {
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+ struct ept_data *ept = &p2m->ept;
+
+ ept->asr = pagetable_get_pfn(p2m_get_pagetable(p2m));
+ __vmwrite(EPT_POINTER, ept_get_eptp(ept));
+ }

if ( cpu_has_vmx_pat && paging_mode_hap(d) )
{
diff --git a/xen/arch/x86/hvm/vmx/vmx.c b/xen/arch/x86/hvm/vmx/vmx.c
index 4abfa90..d74aae0 100644
--- a/xen/arch/x86/hvm/vmx/vmx.c
+++ b/xen/arch/x86/hvm/vmx/vmx.c
@@ -74,38 +74,19 @@ static void vmx_fpu_dirty_intercept(void);
static int vmx_msr_read_intercept(unsigned int msr, uint64_t *msr_content);
static int vmx_msr_write_intercept(unsigned int msr, uint64_t msr_content);
static void vmx_invlpg_intercept(unsigned long vaddr);
-static void __ept_sync_domain(void *info);

static int vmx_domain_initialise(struct domain *d)
{
int rc;

- /* Set the memory type used when accessing EPT paging structures. */
- d->arch.hvm_domain.vmx.ept_control.ept_mt = EPT_DEFAULT_MT;
-
- /* set EPT page-walk length, now it's actual walk length - 1, i.e. 3 */
- d->arch.hvm_domain.vmx.ept_control.ept_wl = 3;
-
- d->arch.hvm_domain.vmx.ept_control.asr =
- pagetable_get_pfn(p2m_get_pagetable(p2m_get_hostp2m(d)));
-
- if ( !zalloc_cpumask_var(&d->arch.hvm_domain.vmx.ept_synced) )
- return -ENOMEM;
-
if ( (rc = vmx_alloc_vlapic_mapping(d)) != 0 )
- {
- free_cpumask_var(d->arch.hvm_domain.vmx.ept_synced);
return rc;
- }

return 0;
}

static void vmx_domain_destroy(struct domain *d)
{
- if ( paging_mode_hap(d) )
- on_each_cpu(__ept_sync_domain, d, 1);
- free_cpumask_var(d->arch.hvm_domain.vmx.ept_synced);
vmx_free_vlapic_mapping(d);
}

@@ -641,6 +622,7 @@ static void vmx_ctxt_switch_to(struct vcpu *v)
{
struct domain *d = v->domain;
unsigned long old_cr4 = read_cr4(), new_cr4 = mmu_cr4_features;
+ struct ept_data *ept_data = &p2m_get_hostp2m(d)->ept;

/* HOST_CR4 in VMCS is always mmu_cr4_features. Sync CR4 now. */
if ( old_cr4 != new_cr4 )
@@ -650,10 +632,10 @@ static void vmx_ctxt_switch_to(struct vcpu *v)
{
unsigned int cpu = smp_processor_id();
/* Test-and-test-and-set this CPU in the EPT-is-synced mask. */
- if ( !cpumask_test_cpu(cpu, d->arch.hvm_domain.vmx.ept_synced) &&
+ if ( !cpumask_test_cpu(cpu, ept_get_synced_mask(ept_data)) &&
!cpumask_test_and_set_cpu(cpu,
- d->arch.hvm_domain.vmx.ept_synced) )
- __invept(INVEPT_SINGLE_CONTEXT, ept_get_eptp(d), 0);
+ ept_get_synced_mask(ept_data)) )
+ __invept(INVEPT_SINGLE_CONTEXT, ept_get_eptp(ept_data), 0);
}

vmx_restore_guest_msrs(v);
@@ -1216,33 +1198,6 @@ static void vmx_update_guest_efer(struct vcpu *v)
(v->arch.hvm_vcpu.guest_efer & EFER_SCE));
}

-static void __ept_sync_domain(void *info)
-{
- struct domain *d = info;
- __invept(INVEPT_SINGLE_CONTEXT, ept_get_eptp(d), 0);
-}
-
-void ept_sync_domain(struct domain *d)
-{
- /* Only if using EPT and this domain has some VCPUs to dirty. */
- if ( !paging_mode_hap(d) || !d->vcpu || !d->vcpu[0] )
- return;
-
- ASSERT(local_irq_is_enabled());
-
- /*
- * Flush active cpus synchronously. Flush others the next time this domain
- * is scheduled onto them. We accept the race of other CPUs adding to
- * the ept_synced mask before on_selected_cpus() reads it, resulting in
- * unnecessary extra flushes, to avoid allocating a cpumask_t on the stack.
- */
- cpumask_and(d->arch.hvm_domain.vmx.ept_synced,
- d->domain_dirty_cpumask, &cpu_online_map);
-
- on_selected_cpus(d->arch.hvm_domain.vmx.ept_synced,
- __ept_sync_domain, d, 1);
-}
-
void nvmx_enqueue_n2_exceptions(struct vcpu *v,
unsigned long intr_fields, int error_code)
{
diff --git a/xen/arch/x86/mm/p2m-ept.c b/xen/arch/x86/mm/p2m-ept.c
index c964f54..e33f415 100644
--- a/xen/arch/x86/mm/p2m-ept.c
+++ b/xen/arch/x86/mm/p2m-ept.c
@@ -291,9 +291,11 @@ ept_set_entry(struct p2m_domain *p2m, unsigned long gfn, mfn_t mfn,
int need_modify_vtd_table = 1;
int vtd_pte_present = 0;
int needs_sync = 1;
- struct domain *d = p2m->domain;
ept_entry_t old_entry = { .epte = 0 };
+ struct ept_data *ept = &p2m->ept;
+ struct domain *d = p2m->domain;

+ ASSERT(ept);
/*
* the caller must make sure:
* 1. passing valid gfn and mfn at order boundary.
@@ -301,17 +303,17 @@ ept_set_entry(struct p2m_domain *p2m, unsigned long gfn, mfn_t mfn,
* 3. passing a valid order.
*/
if ( ((gfn | mfn_x(mfn)) & ((1UL << order) - 1)) ||
- ((u64)gfn >> ((ept_get_wl(d) + 1) * EPT_TABLE_ORDER)) ||
+ ((u64)gfn >> ((ept_get_wl(ept) + 1) * EPT_TABLE_ORDER)) ||
(order % EPT_TABLE_ORDER) )
return 0;

- ASSERT((target == 2 && hvm_hap_has_1gb(d)) ||
- (target == 1 && hvm_hap_has_2mb(d)) ||
+ ASSERT((target == 2 && hvm_hap_has_1gb()) ||
+ (target == 1 && hvm_hap_has_2mb()) ||
(target == 0));

- table = map_domain_page(ept_get_asr(d));
+ table = map_domain_page(pagetable_get_pfn(p2m_get_pagetable(p2m)));

- for ( i = ept_get_wl(d); i > target; i-- )
+ for ( i = ept_get_wl(ept); i > target; i-- )
{
ret = ept_next_level(p2m, 0, &table, &gfn_remainder, i);
if ( !ret )
@@ -439,9 +441,11 @@ out:
unmap_domain_page(table);

if ( needs_sync )
- ept_sync_domain(p2m->domain);
+ ept_sync_domain(p2m);

- if ( rv && iommu_enabled && need_iommu(p2m->domain) && need_modify_vtd_table )
+ /* For non-nested p2m, may need to change VT-d page table.*/
+ if ( rv && !p2m_is_nestedp2m(p2m) && iommu_enabled && need_iommu(p2m->domain) &&
+ need_modify_vtd_table )
{
if ( iommu_hap_pt_share )
iommu_pte_flush(d, gfn, (u64*)ept_entry, order, vtd_pte_present);
@@ -488,14 +492,14 @@ static mfn_t ept_get_entry(struct p2m_domain *p2m,
unsigned long gfn, p2m_type_t *t, p2m_access_t* a,
p2m_query_t q, unsigned int *page_order)
{
- struct domain *d = p2m->domain;
- ept_entry_t *table = map_domain_page(ept_get_asr(d));
+ ept_entry_t *table = map_domain_page(pagetable_get_pfn(p2m_get_pagetable(p2m)));
unsigned long gfn_remainder = gfn;
ept_entry_t *ept_entry;
u32 index;
int i;
int ret = 0;
mfn_t mfn = _mfn(INVALID_MFN);
+ struct ept_data *ept = &p2m->ept;

*t = p2m_mmio_dm;
*a = p2m_access_n;
@@ -506,7 +510,7 @@ static mfn_t ept_get_entry(struct p2m_domain *p2m,

/* Should check if gfn obeys GAW here. */

- for ( i = ept_get_wl(d); i > 0; i-- )
+ for ( i = ept_get_wl(ept); i > 0; i-- )
{
retry:
ret = ept_next_level(p2m, 1, &table, &gfn_remainder, i);
@@ -588,19 +592,20 @@ out:
static ept_entry_t ept_get_entry_content(struct p2m_domain *p2m,
unsigned long gfn, int *level)
{
- ept_entry_t *table = map_domain_page(ept_get_asr(p2m->domain));
+ ept_entry_t *table = map_domain_page(pagetable_get_pfn(p2m_get_pagetable(p2m)));
unsigned long gfn_remainder = gfn;
ept_entry_t *ept_entry;
ept_entry_t content = { .epte = 0 };
u32 index;
int i;
int ret=0;
+ struct ept_data *ept = &p2m->ept;

/* This pfn is higher than the highest the p2m map currently holds */
if ( gfn > p2m->max_mapped_pfn )
goto out;

- for ( i = ept_get_wl(p2m->domain); i > 0; i-- )
+ for ( i = ept_get_wl(ept); i > 0; i-- )
{
ret = ept_next_level(p2m, 1, &table, &gfn_remainder, i);
if ( !ret || ret == GUEST_TABLE_POD_PAGE )
@@ -622,7 +627,8 @@ static ept_entry_t ept_get_entry_content(struct p2m_domain *p2m,
void ept_walk_table(struct domain *d, unsigned long gfn)
{
struct p2m_domain *p2m = p2m_get_hostp2m(d);
- ept_entry_t *table = map_domain_page(ept_get_asr(d));
+ struct ept_data *ept = &p2m->ept;
+ ept_entry_t *table = map_domain_page(pagetable_get_pfn(p2m_get_pagetable(p2m)));
unsigned long gfn_remainder = gfn;

int i;
@@ -638,7 +644,7 @@ void ept_walk_table(struct domain *d, unsigned long gfn)
goto out;
}

- for ( i = ept_get_wl(d); i >= 0; i-- )
+ for ( i = ept_get_wl(ept); i >= 0; i-- )
{
ept_entry_t *ept_entry, *next;
u32 index;
@@ -778,24 +784,76 @@ static void ept_change_entry_type_page(mfn_t ept_page_mfn, int ept_page_level,
static void ept_change_entry_type_global(struct p2m_domain *p2m,
p2m_type_t ot, p2m_type_t nt)
{
- struct domain *d = p2m->domain;
- if ( ept_get_asr(d) == 0 )
+ struct ept_data *ept = &p2m->ept;
+ if ( ept_get_asr(ept) == 0 )
return;

BUG_ON(p2m_is_grant(ot) || p2m_is_grant(nt));
BUG_ON(ot != nt && (ot == p2m_mmio_direct || nt == p2m_mmio_direct));

- ept_change_entry_type_page(_mfn(ept_get_asr(d)), ept_get_wl(d), ot, nt);
+ ept_change_entry_type_page(_mfn(ept_get_asr(ept)),
+ ept_get_wl(ept), ot, nt);
+
+ ept_sync_domain(p2m);
+}
+
+static void __ept_sync_domain(void *info)
+{
+ struct ept_data *ept = &((struct p2m_domain *)info)->ept;

- ept_sync_domain(d);
+ __invept(INVEPT_SINGLE_CONTEXT, ept_get_eptp(ept), 0);
}

-void ept_p2m_init(struct p2m_domain *p2m)
+void ept_sync_domain(struct p2m_domain *p2m)
{
+ struct domain *d = p2m->domain;
+ struct ept_data *ept = &p2m->ept;
+ /* Only if using EPT and this domain has some VCPUs to dirty. */
+ if ( !paging_mode_hap(d) || !d->vcpu || !d->vcpu[0] )
+ return;
+
+ ASSERT(local_irq_is_enabled());
+
+ /*
+ * Flush active cpus synchronously. Flush others the next time this domain
+ * is scheduled onto them. We accept the race of other CPUs adding to
+ * the ept_synced mask before on_selected_cpus() reads it, resulting in
+ * unnecessary extra flushes, to avoid allocating a cpumask_t on the stack.
+ */
+ cpumask_and(ept_get_synced_mask(ept),
+ d->domain_dirty_cpumask, &cpu_online_map);
+
+ on_selected_cpus(ept_get_synced_mask(ept),
+ __ept_sync_domain, p2m, 1);
+}
+
+int ept_p2m_init(struct p2m_domain *p2m)
+{
+ struct ept_data *ept = &p2m->ept;
+
p2m->set_entry = ept_set_entry;
p2m->get_entry = ept_get_entry;
p2m->change_entry_type_global = ept_change_entry_type_global;
p2m->audit_p2m = NULL;
+
+ /* Set the memory type used when accessing EPT paging structures. */
+ ept->ept_mt = EPT_DEFAULT_MT;
+
+ /* set EPT page-walk length, now it's actual walk length - 1, i.e. 3 */
+ ept->ept_wl = 3;
+
+ if ( !zalloc_cpumask_var(&ept->synced_mask) )
+ return -ENOMEM;
+
+ on_each_cpu(__ept_sync_domain, p2m, 1);
+
+ return 0;
+}
+
+void ept_p2m_uninit(struct p2m_domain *p2m)
+{
+ struct ept_data *ept = &p2m->ept;
+ free_cpumask_var(ept->synced_mask);
}

static void ept_dump_p2m_table(unsigned char key)
@@ -811,6 +869,7 @@ static void ept_dump_p2m_table(unsigned char key)
unsigned long gfn, gfn_remainder;
unsigned long record_counter = 0;
struct p2m_domain *p2m;
+ struct ept_data *ept;

for_each_domain(d)
{
@@ -818,15 +877,16 @@ static void ept_dump_p2m_table(unsigned char key)
continue;

p2m = p2m_get_hostp2m(d);
+ ept = &p2m->ept;
printk("\ndomain%d EPT p2m table: \n", d->domain_id);

for ( gfn = 0; gfn <= p2m->max_mapped_pfn; gfn += (1 << order) )
{
gfn_remainder = gfn;
mfn = _mfn(INVALID_MFN);
- table = map_domain_page(ept_get_asr(d));
+ table = map_domain_page(pagetable_get_pfn(p2m_get_pagetable(p2m)));

- for ( i = ept_get_wl(d); i > 0; i-- )
+ for ( i = ept_get_wl(ept); i > 0; i-- )
{
ret = ept_next_level(p2m, 1, &table, &gfn_remainder, i);
if ( ret != GUEST_TABLE_NORMAL_PAGE )
diff --git a/xen/arch/x86/mm/p2m.c b/xen/arch/x86/mm/p2m.c
index 41a461b..49eb8af 100644
--- a/xen/arch/x86/mm/p2m.c
+++ b/xen/arch/x86/mm/p2m.c
@@ -57,8 +57,10 @@ boolean_param("hap_2mb", opt_hap_2mb);

/* Init the datastructures for later use by the p2m code */
-static void p2m_initialise(struct domain *d, struct p2m_domain *p2m)
+static int p2m_initialise(struct domain *d, struct p2m_domain *p2m)
{
+ int ret = 0;
+
mm_rwlock_init(&p2m->lock);
mm_lock_init(&p2m->pod.lock);
INIT_LIST_HEAD(&p2m->np2m_list);
@@ -72,27 +74,81 @@ static void p2m_initialise(struct domain *d, struct p2m_domain *p2m)
p2m->np2m_base = P2M_BASE_EADDR;

if ( hap_enabled(d) && cpu_has_vmx )
- ept_p2m_init(p2m);
+ ret = ept_p2m_init(p2m);
else
p2m_pt_init(p2m);

- return;
+ return ret;
+}
+
+static struct p2m_domain *p2m_init_one(struct domain *d)
+{
+ struct p2m_domain *p2m = xzalloc(struct p2m_domain);
+
+ if ( !p2m )
+ return NULL;
+
+ if ( !zalloc_cpumask_var(&p2m->dirty_cpumask) )
+ goto free_p2m;
+
+ if ( p2m_initialise(d, p2m) )
+ goto free_cpumask;
+ return p2m;
+
+free_cpumask:
+ free_cpumask_var(p2m->dirty_cpumask);
+free_p2m:
+ xfree(p2m);
+ return NULL;
}

-static int
-p2m_init_nestedp2m(struct domain *d)
+static void p2m_free_one(struct p2m_domain *p2m)
+{
+ if ( hap_enabled(p2m->domain) && cpu_has_vmx )
+ ept_p2m_uninit(p2m);
+ free_cpumask_var(p2m->dirty_cpumask);
+ xfree(p2m);
+}
+
+static int p2m_init_hostp2m(struct domain *d)
+{
+ struct p2m_domain *p2m = p2m_init_one(d);
+
+ if ( p2m )
+ {
+ d->arch.p2m = p2m;
+ return 0;
+ }
+ return -ENOMEM;
+}
+
+static void p2m_teardown_hostp2m(struct domain *d)
+{
+ /* Iterate over all p2m tables per domain */
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+
+ if ( p2m ) {
+ p2m_free_one(p2m);
+ d->arch.p2m = NULL;
+ }
+}
+
+static void p2m_teardown_nestedp2m(struct domain *d);
+
+static int p2m_init_nestedp2m(struct domain *d)
{
uint8_t i;
struct p2m_domain *p2m;

mm_lock_init(&d->arch.nested_p2m_lock);
- for (i = 0; i < MAX_NESTEDP2M; i++) {
- d->arch.nested_p2m = p2m = xzalloc(struct p2m_domain);
- if (p2m == NULL)
- return -ENOMEM;
- if ( !zalloc_cpumask_var(&p2m->dirty_cpumask) )
+ for (i = 0; i < MAX_NESTEDP2M; i++)
+ {
+ d->arch.nested_p2m = p2m = p2m_init_one(d);
+ if ( p2m == NULL )
+ {
+ p2m_teardown_nestedp2m(d);
return -ENOMEM;
- p2m_initialise(d, p2m);
+ }
p2m->write_p2m_entry = nestedp2m_write_p2m_entry;
list_add(&p2m->np2m_list, &p2m_get_hostp2m(d)->np2m_list);
}
@@ -100,27 +156,37 @@ p2m_init_nestedp2m(struct domain *d)
return 0;
}

-int p2m_init(struct domain *d)
+static void p2m_teardown_nestedp2m(struct domain *d)
{
+ uint8_t i;
struct p2m_domain *p2m;
- int rc;

- p2m_get_hostp2m(d) = p2m = xzalloc(struct p2m_domain);
- if ( p2m == NULL )
- return -ENOMEM;
- if ( !zalloc_cpumask_var(&p2m->dirty_cpumask) )
+ for (i = 0; i < MAX_NESTEDP2M; i++)
{
- xfree(p2m);
- return -ENOMEM;
+ if ( !d->arch.nested_p2m )
+ continue;
+ p2m = d->arch.nested_p2m;
+ list_del(&p2m->np2m_list);
+ p2m_free_one(p2m);
+ d->arch.nested_p2m = NULL;
}
- p2m_initialise(d, p2m);
+}
+
+int p2m_init(struct domain *d)
+{
+ int rc;
+
+ rc = p2m_init_hostp2m(d);
+ if ( rc )
+ return rc;

/* Must initialise nestedp2m unconditionally
* since nestedhvm_enabled(d) returns false here.
* (p2m_init runs too early for HVM_PARAM_* options) */
rc = p2m_init_nestedp2m(d);
- if ( rc )
- p2m_final_teardown(d);
+ if ( rc )
+ p2m_teardown_hostp2m(d);
+
return rc;
}

@@ -421,28 +487,12 @@ void p2m_teardown(struct p2m_domain *p2m)
p2m_unlock(p2m);
}

-static void p2m_teardown_nestedp2m(struct domain *d)
-{
- uint8_t i;
-
- for (i = 0; i < MAX_NESTEDP2M; i++) {
- if ( !d->arch.nested_p2m )
- continue;
- free_cpumask_var(d->arch.nested_p2m->dirty_cpumask);
- xfree(d->arch.nested_p2m);
- d->arch.nested_p2m = NULL;
- }
-}
-
void p2m_final_teardown(struct domain *d)
{
/* Iterate over all p2m tables per domain */
- if ( d->arch.p2m )
- {
- free_cpumask_var(d->arch.p2m->dirty_cpumask);
- xfree(d->arch.p2m);
- d->arch.p2m = NULL;
- }
+ struct p2m_domain *p2m = p2m_get_hostp2m(d);
+ if ( p2m )
+ p2m_teardown_hostp2m(d);

/* We must teardown unconditionally because
* we initialise them unconditionally.
diff --git a/xen/include/asm-x86/hvm/vmx/vmcs.h b/xen/include/asm-x86/hvm/vmx/vmcs.h
index 9a728b6..2d38b43 100644
--- a/xen/include/asm-x86/hvm/vmx/vmcs.h
+++ b/xen/include/asm-x86/hvm/vmx/vmcs.h
@@ -56,26 +56,27 @@ struct vmx_msr_state {

#define EPT_DEFAULT_MT MTRR_TYPE_WRBACK

-struct vmx_domain {
- unsigned long apic_access_mfn;
+struct ept_data{
union {
- struct {
+ struct {
u64 ept_mt :3,
ept_wl :3,
rsvd :6,
asr :52;
};
u64 eptp;
- } ept_control;
- cpumask_var_t ept_synced;
+ };
+ cpumask_var_t synced_mask;
+};
+
+struct vmx_domain {
+ unsigned long apic_access_mfn;
};

-#define ept_get_wl(d) \
- ((d)->arch.hvm_domain.vmx.ept_control.ept_wl)
-#define ept_get_asr(d) \
- ((d)->arch.hvm_domain.vmx.ept_control.asr)
-#define ept_get_eptp(d) \
- ((d)->arch.hvm_domain.vmx.ept_control.eptp)
+#define ept_get_wl(ept) ((ept)->ept_wl)
+#define ept_get_asr(ept) ((ept)->asr)
+#define ept_get_eptp(ept) ((ept)->eptp)
+#define ept_get_synced_mask(ept) ((ept)->synced_mask)

struct arch_vmx_struct {
/* Virtual address of VMCS. */
diff --git a/xen/include/asm-x86/hvm/vmx/vmx.h b/xen/include/asm-x86/hvm/vmx/vmx.h
index c73946f..d4d6feb 100644
--- a/xen/include/asm-x86/hvm/vmx/vmx.h
+++ b/xen/include/asm-x86/hvm/vmx/vmx.h
@@ -363,7 +363,7 @@ static inline void ept_sync_all(void)
__invept(INVEPT_ALL_CONTEXT, 0, 0);
}

-void ept_sync_domain(struct domain *d);
+void ept_sync_domain(struct p2m_domain *p2m);

static inline void vpid_sync_vcpu_gva(struct vcpu *v, unsigned long gva)
{
@@ -425,12 +425,18 @@ void vmx_get_segment_register(struct vcpu *, enum x86_segment,
void vmx_inject_extint(int trap);
void vmx_inject_nmi(void);

-void ept_p2m_init(struct p2m_domain *p2m);
+int ept_p2m_init(struct p2m_domain *p2m);
+void ept_p2m_uninit(struct p2m_domain *p2m);
+
void ept_walk_table(struct domain *d, unsigned long gfn);
void setup_ept_dump(void);

void update_guest_eip(void);

+int alloc_p2m_hap_data(struct p2m_domain *p2m);
+void free_p2m_hap_data(struct p2m_domain *p2m);
+void p2m_init_hap_data(struct p2m_domain *p2m);
+
/* EPT violation qualifications definitions */
#define _EPT_READ_VIOLATION 0
#define EPT_READ_VIOLATION (1UL<<_EPT_READ_VIOLATION)
diff --git a/xen/include/asm-x86/p2m.h b/xen/include/asm-x86/p2m.h
index ce26594..b6a84b6 100644
--- a/xen/include/asm-x86/p2m.h
+++ b/xen/include/asm-x86/p2m.h
@@ -277,6 +277,10 @@ struct p2m_domain {
mm_lock_t lock; /* Locking of private pod structs, *
* not relying on the p2m lock. */
} pod;
+ union {
+ struct ept_data ept;
+ /* NPT-equivalent structure could be added here. */
+ };
};

/* get host p2m table */
--
1.7.1

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH v4 09/10] nVMX: virutalize VPID capability to nested VMM. (no replies)

Xiantao Zhang — Mon, 24 Dec 2012 22:31:37 +0800

From: Zhang Xiantao

Virtualize VPID for the nested vmm, use host's VPID
to emualte guest's VPID. For each virtual vmentry, if
guest'v vpid is changed, allocate a new host VPID for
L2 guest.

Signed-off-by: Zhang Xiantao
Acked-by: Tim Deegan
---
xen/arch/x86/hvm/vmx/vmx.c | 11 ++++++-
xen/arch/x86/hvm/vmx/vvmx.c | 52 +++++++++++++++++++++++++++++++++++-
xen/include/asm-x86/hvm/vmx/vvmx.h | 2 +
3 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/xen/arch/x86/hvm/vmx/vmx.c b/xen/arch/x86/hvm/vmx/vmx.c
index 94cac17..0e479f8 100644
--- a/xen/arch/x86/hvm/vmx/vmx.c
+++ b/xen/arch/x86/hvm/vmx/vmx.c
@@ -2578,10 +2578,14 @@ void vmx_vmexit_handler(struct cpu_user_regs *regs)
update_guest_eip();
break;

+ case EXIT_REASON_INVVPID:
+ if ( nvmx_handle_invvpid(regs) == X86EMUL_OKAY )
+ update_guest_eip();
+ break;
+
case EXIT_REASON_MWAIT_INSTRUCTION:
case EXIT_REASON_MONITOR_INSTRUCTION:
case EXIT_REASON_GETSEC:
- case EXIT_REASON_INVVPID:
/*
* We should never exit on GETSEC because CR4.SMXE is always 0 when
* running in guest context, and the CPU checks that before getting
@@ -2699,8 +2703,11 @@ void vmx_vmenter_helper(void)

if ( !cpu_has_vmx_vpid )
goto out;
+ if ( nestedhvm_vcpu_in_guestmode(curr) )
+ p_asid = &vcpu_nestedhvm(curr).nv_n2asid;
+ else
+ p_asid = &curr->arch.hvm_vcpu.n1asid;

- p_asid = &curr->arch.hvm_vcpu.n1asid;
old_asid = p_asid->asid;
need_flush = hvm_asid_handle_vmenter(p_asid);
new_asid = p_asid->asid;
diff --git a/xen/arch/x86/hvm/vmx/vvmx.c b/xen/arch/x86/hvm/vmx/vvmx.c
index c31f7ba..c54ee44 100644
--- a/xen/arch/x86/hvm/vmx/vvmx.c
+++ b/xen/arch/x86/hvm/vmx/vvmx.c
@@ -42,6 +42,7 @@ int nvmx_vcpu_initialise(struct vcpu *v)
goto out;
}
nvmx->ept.enabled = 0;
+ nvmx->guest_vpid = 0;
nvmx->vmxon_region_pa = 0;
nvcpu->nv_vvmcx = NULL;
nvcpu->nv_vvmcxaddr = VMCX_EADDR;
@@ -882,6 +883,16 @@ static uint64_t get_shadow_eptp(struct vcpu *v)
return ept_get_eptp(ept);
}

+static bool_t nvmx_vpid_enabled(struct nestedvcpu *nvcpu)
+{
+ uint32_t second_cntl;
+
+ second_cntl = __get_vvmcs(nvcpu->nv_vvmcx, SECONDARY_VM_EXEC_CONTROL);
+ if ( second_cntl & SECONDARY_EXEC_ENABLE_VPID )
+ return 1;
+ return 0;
+}
+
static void virtual_vmentry(struct cpu_user_regs *regs)
{
struct vcpu *v = current;
@@ -930,6 +941,18 @@ static void virtual_vmentry(struct cpu_user_regs *regs)
if ( nestedhvm_paging_mode_hap(v) )
__vmwrite(EPT_POINTER, get_shadow_eptp(v));

+ /* nested VPID support! */
+ if ( cpu_has_vmx_vpid && nvmx_vpid_enabled(nvcpu) )
+ {
+ struct nestedvmx *nvmx = &vcpu_2_nvmx(v);
+ uint32_t new_vpid = __get_vvmcs(vvmcs, VIRTUAL_PROCESSOR_ID);
+ if ( nvmx->guest_vpid != new_vpid )
+ {
+ hvm_asid_flush_vcpu_asid(&vcpu_nestedhvm(v).nv_n2asid);
+ nvmx->guest_vpid = new_vpid;
+ }
+ }
+
}

static void sync_vvmcs_guest_state(struct vcpu *v, struct cpu_user_regs *regs)
@@ -1221,7 +1244,7 @@ int nvmx_handle_vmlaunch(struct cpu_user_regs *regs)
if ( vcpu_nestedhvm(v).nv_vvmcxaddr == VMCX_EADDR )
{
vmreturn (regs, VMFAIL_INVALID);
- return X86EMUL_OKAY;
+ return X86EMUL_OKAY;
}

launched = __get_vvmcs(vcpu_nestedhvm(v).nv_vvmcx,
@@ -1433,6 +1456,33 @@ int nvmx_handle_invept(struct cpu_user_regs *regs)
(((__emul_value(enable1, default1) & host_value) & (~0ul << 32)) | \
((uint32_t)(__emul_value(enable1, default1) | host_value)))

+int nvmx_handle_invvpid(struct cpu_user_regs *regs)
+{
+ struct vmx_inst_decoded decode;
+ unsigned long vpid;
+ u64 inv_type;
+
+ if ( decode_vmx_inst(regs, &decode, &vpid, 0) != X86EMUL_OKAY )
+ return X86EMUL_EXCEPTION;
+
+ inv_type = reg_read(regs, decode.reg2);
+
+ switch ( inv_type ) {
+ /* Just invalidate all tlb entries for all types! */
+ case INVVPID_INDIVIDUAL_ADDR:
+ case INVVPID_SINGLE_CONTEXT:
+ case INVVPID_ALL_CONTEXT:
+ hvm_asid_flush_vcpu_asid(&vcpu_nestedhvm(current).nv_n2asid);
+ break;
+ default:
+ vmreturn(regs, VMFAIL_INVALID);
+ return X86EMUL_OKAY;
+ }
+
+ vmreturn(regs, VMSUCCEED);
+ return X86EMUL_OKAY;
+}
+
/*
* Capability reporting
*/
diff --git a/xen/include/asm-x86/hvm/vmx/vvmx.h b/xen/include/asm-x86/hvm/vmx/vvmx.h
index e671635..d1368a3 100644
--- a/xen/include/asm-x86/hvm/vmx/vvmx.h
+++ b/xen/include/asm-x86/hvm/vmx/vvmx.h
@@ -37,6 +37,7 @@ struct nestedvmx {
uint32_t exit_reason;
uint32_t exit_qual;
} ept;
+ uint32_t guest_vpid;
};

#define vcpu_2_nvmx(v) (vcpu_nestedhvm(v).u.nvmx)
@@ -190,6 +191,7 @@ int nvmx_handle_vmwrite(struct cpu_user_regs *regs);
int nvmx_handle_vmresume(struct cpu_user_regs *regs);
int nvmx_handle_vmlaunch(struct cpu_user_regs *regs);
int nvmx_handle_invept(struct cpu_user_regs *regs);
+int nvmx_handle_invvpid(struct cpu_user_regs *regs);
int nvmx_msr_read_intercept(unsigned int msr,
u64 *msr_content);
int nvmx_msr_write_intercept(unsigned int msr,
--
1.7.1

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH v4 01/10] nestedhap: Change hostcr3 and p2m->cr3 to meaningful words (no replies)

Xiantao Zhang — Mon, 24 Dec 2012 22:31:35 +0800

From: Zhang Xiantao

VMX doesn't have the concept about host cr3 for nested p2m,
and only SVM has, so change it to netural words.

Signed-off-by: Zhang Xiantao
Acked-by: Tim Deegan
---
xen/arch/x86/hvm/hvm.c | 6 +++---
xen/arch/x86/hvm/svm/svm.c | 2 +-
xen/arch/x86/hvm/vmx/vmx.c | 2 +-
xen/arch/x86/hvm/vmx/vvmx.c | 2 +-
xen/arch/x86/mm/hap/nested_hap.c | 15 ++++++++-------
xen/arch/x86/mm/mm-locks.h | 2 +-
xen/arch/x86/mm/p2m.c | 26 +++++++++++++-------------
xen/include/asm-x86/hvm/hvm.h | 4 ++--
xen/include/asm-x86/hvm/vmx/vvmx.h | 2 +-
xen/include/asm-x86/p2m.h | 16 ++++++++--------
10 files changed, 39 insertions(+), 38 deletions(-)

diff --git a/xen/arch/x86/hvm/hvm.c b/xen/arch/x86/hvm/hvm.c
index 40c1ab2..f63ee52 100644
--- a/xen/arch/x86/hvm/hvm.c
+++ b/xen/arch/x86/hvm/hvm.c
@@ -4536,10 +4536,10 @@ uint64_t nhvm_vcpu_guestcr3(struct vcpu *v)
return -EOPNOTSUPP;
}

-uint64_t nhvm_vcpu_hostcr3(struct vcpu *v)
+uint64_t nhvm_vcpu_p2m_base(struct vcpu *v)
{
- if (hvm_funcs.nhvm_vcpu_hostcr3)
- return hvm_funcs.nhvm_vcpu_hostcr3(v);
+ if ( hvm_funcs.nhvm_vcpu_p2m_base )
+ return hvm_funcs.nhvm_vcpu_p2m_base(v);
return -EOPNOTSUPP;
}

diff --git a/xen/arch/x86/hvm/svm/svm.c b/xen/arch/x86/hvm/svm/svm.c
index 55a5ae5..2c8504a 100644
--- a/xen/arch/x86/hvm/svm/svm.c
+++ b/xen/arch/x86/hvm/svm/svm.c
@@ -2003,7 +2003,7 @@ static struct hvm_function_table __read_mostly svm_function_table = {
.nhvm_vcpu_vmexit = nsvm_vcpu_vmexit_inject,
.nhvm_vcpu_vmexit_trap = nsvm_vcpu_vmexit_trap,
.nhvm_vcpu_guestcr3 = nsvm_vcpu_guestcr3,
- .nhvm_vcpu_hostcr3 = nsvm_vcpu_hostcr3,
+ .nhvm_vcpu_p2m_base = nsvm_vcpu_hostcr3,
.nhvm_vcpu_asid = nsvm_vcpu_asid,
.nhvm_vmcx_guest_intercepts_trap = nsvm_vmcb_guest_intercepts_trap,
.nhvm_vmcx_hap_enabled = nsvm_vmcb_hap_enabled,
diff --git a/xen/arch/x86/hvm/vmx/vmx.c b/xen/arch/x86/hvm/vmx/vmx.c
index aee1f9e..98309da 100644
--- a/xen/arch/x86/hvm/vmx/vmx.c
+++ b/xen/arch/x86/hvm/vmx/vmx.c
@@ -1504,7 +1504,7 @@ static struct hvm_function_table __read_mostly vmx_function_table = {
.nhvm_vcpu_destroy = nvmx_vcpu_destroy,
.nhvm_vcpu_reset = nvmx_vcpu_reset,
.nhvm_vcpu_guestcr3 = nvmx_vcpu_guestcr3,
- .nhvm_vcpu_hostcr3 = nvmx_vcpu_hostcr3,
+ .nhvm_vcpu_p2m_base = nvmx_vcpu_eptp_base,
.nhvm_vcpu_asid = nvmx_vcpu_asid,
.nhvm_vmcx_guest_intercepts_trap = nvmx_intercepts_exception,
.nhvm_vcpu_vmexit_trap = nvmx_vmexit_trap,
diff --git a/xen/arch/x86/hvm/vmx/vvmx.c b/xen/arch/x86/hvm/vmx/vvmx.c
index 7b27d2d..6999c25 100644
--- a/xen/arch/x86/hvm/vmx/vvmx.c
+++ b/xen/arch/x86/hvm/vmx/vvmx.c
@@ -94,7 +94,7 @@ uint64_t nvmx_vcpu_guestcr3(struct vcpu *v)
return 0;
}

-uint64_t nvmx_vcpu_hostcr3(struct vcpu *v)
+uint64_t nvmx_vcpu_eptp_base(struct vcpu *v)
{
/* TODO */
ASSERT(0);
diff --git a/xen/arch/x86/mm/hap/nested_hap.c b/xen/arch/x86/mm/hap/nested_hap.c
index 317875d..f9a5edc 100644
--- a/xen/arch/x86/mm/hap/nested_hap.c
+++ b/xen/arch/x86/mm/hap/nested_hap.c
@@ -48,9 +48,10 @@
* 1. If #NPF is from L1 guest, then we crash the guest VM (same as old
* code)
* 2. If #NPF is from L2 guest, then we continue from (3)
- * 3. Get h_cr3 from L1 guest. Map h_cr3 into L0 hypervisor address space.
- * 4. Walk the h_cr3 page table
- * 5. - if not present, then we inject #NPF back to L1 guest and
+ * 3. Get np2m base from L1 guest. Map np2m base into L0 hypervisor address space.
+ * 4. Walk the np2m's page table
+ * 5. - if not present or permission check failure, then we inject #NPF back to
+ * L1 guest and
* re-launch L1 guest (L1 guest will either treat this #NPF as MMIO,
* or fix its p2m table for L2 guest)
* 6. - if present, then we will get the a new translated value L1-GPA
@@ -89,7 +90,7 @@ nestedp2m_write_p2m_entry(struct p2m_domain *p2m, unsigned long gfn,

if (old_flags & _PAGE_PRESENT)
flush_tlb_mask(p2m->dirty_cpumask);
-
+
paging_unlock(d);
}

@@ -110,7 +111,7 @@ nestedhap_fix_p2m(struct vcpu *v, struct p2m_domain *p2m,
/* If this p2m table has been flushed or recycled under our feet,
* leave it alone. We'll pick up the right one as we try to
* vmenter the guest. */
- if ( p2m->cr3 == nhvm_vcpu_hostcr3(v) )
+ if ( p2m->np2m_base == nhvm_vcpu_p2m_base(v) )
{
unsigned long gfn, mask;
mfn_t mfn;
@@ -186,7 +187,7 @@ nestedhap_walk_L1_p2m(struct vcpu *v, paddr_t L2_gpa, paddr_t *L1_gpa,
uint32_t pfec;
unsigned long nested_cr3, gfn;

- nested_cr3 = nhvm_vcpu_hostcr3(v);
+ nested_cr3 = nhvm_vcpu_p2m_base(v);

pfec = PFEC_user_mode | PFEC_page_present;
if (access_w)
@@ -221,7 +222,7 @@ nestedhvm_hap_nested_page_fault(struct vcpu *v, paddr_t *L2_gpa,
p2m_type_t p2mt_10;

p2m = p2m_get_hostp2m(d); /* L0 p2m */
- nested_p2m = p2m_get_nestedp2m(v, nhvm_vcpu_hostcr3(v));
+ nested_p2m = p2m_get_nestedp2m(v, nhvm_vcpu_p2m_base(v));

/* walk the L1 P2M table */
rv = nestedhap_walk_L1_p2m(v, *L2_gpa, &L1_gpa, &page_order_21,
diff --git a/xen/arch/x86/mm/mm-locks.h b/xen/arch/x86/mm/mm-locks.h
index 3700e32..1817f81 100644
--- a/xen/arch/x86/mm/mm-locks.h
+++ b/xen/arch/x86/mm/mm-locks.h
@@ -249,7 +249,7 @@ declare_mm_order_constraint(per_page_sharing)
* A per-domain lock that protects the mapping from nested-CR3 to
* nested-p2m. In particular it covers:
* - the array of nested-p2m tables, and all LRU activity therein; and
- * - setting the "cr3" field of any p2m table to a non-CR3_EADDR value.
+ * - setting the "cr3" field of any p2m table to a non-P2M_BASE_EAADR value.
* (i.e. assigning a p2m table to be the shadow of that cr3 */

/* PoD lock (per-p2m-table)
diff --git a/xen/arch/x86/mm/p2m.c b/xen/arch/x86/mm/p2m.c
index 258f46e..41a461b 100644
--- a/xen/arch/x86/mm/p2m.c
+++ b/xen/arch/x86/mm/p2m.c
@@ -69,7 +69,7 @@ static void p2m_initialise(struct domain *d, struct p2m_domain *p2m)
p2m->domain = d;
p2m->default_access = p2m_access_rwx;

- p2m->cr3 = CR3_EADDR;
+ p2m->np2m_base = P2M_BASE_EADDR;

if ( hap_enabled(d) && cpu_has_vmx )
ept_p2m_init(p2m);
@@ -1433,7 +1433,7 @@ p2m_flush_table(struct p2m_domain *p2m)
ASSERT(page_list_empty(&p2m->pod.single));

/* This is no longer a valid nested p2m for any address space */
- p2m->cr3 = CR3_EADDR;
+ p2m->np2m_base = P2M_BASE_EADDR;

/* Zap the top level of the trie */
top = mfn_to_page(pagetable_get_mfn(p2m_get_pagetable(p2m)));
@@ -1471,7 +1471,7 @@ p2m_flush_nestedp2m(struct domain *d)
}

struct p2m_domain *
-p2m_get_nestedp2m(struct vcpu *v, uint64_t cr3)
+p2m_get_nestedp2m(struct vcpu *v, uint64_t np2m_base)
{
/* Use volatile to prevent gcc to cache nv->nv_p2m in a cpu register as
* this may change within the loop by an other (v)cpu.
@@ -1480,8 +1480,8 @@ p2m_get_nestedp2m(struct vcpu *v, uint64_t cr3)
struct domain *d;
struct p2m_domain *p2m;

- /* Mask out low bits; this avoids collisions with CR3_EADDR */
- cr3 &= ~(0xfffull);
+ /* Mask out low bits; this avoids collisions with P2M_BASE_EADDR */
+ np2m_base &= ~(0xfffull);

if (nv->nv_flushp2m && nv->nv_p2m) {
nv->nv_p2m = NULL;
@@ -1493,14 +1493,14 @@ p2m_get_nestedp2m(struct vcpu *v, uint64_t cr3)
if ( p2m )
{
p2m_lock(p2m);
- if ( p2m->cr3 == cr3 || p2m->cr3 == CR3_EADDR )
+ if ( p2m->np2m_base == np2m_base || p2m->np2m_base == P2M_BASE_EADDR )
{
nv->nv_flushp2m = 0;
p2m_getlru_nestedp2m(d, p2m);
nv->nv_p2m = p2m;
- if (p2m->cr3 == CR3_EADDR)
+ if ( p2m->np2m_base == P2M_BASE_EADDR )
hvm_asid_flush_vcpu(v);
- p2m->cr3 = cr3;
+ p2m->np2m_base = np2m_base;
cpumask_set_cpu(v->processor, p2m->dirty_cpumask);
p2m_unlock(p2m);
nestedp2m_unlock(d);
@@ -1515,7 +1515,7 @@ p2m_get_nestedp2m(struct vcpu *v, uint64_t cr3)
p2m_flush_table(p2m);
p2m_lock(p2m);
nv->nv_p2m = p2m;
- p2m->cr3 = cr3;
+ p2m->np2m_base = np2m_base;
nv->nv_flushp2m = 0;
hvm_asid_flush_vcpu(v);
cpumask_set_cpu(v->processor, p2m->dirty_cpumask);
@@ -1531,7 +1531,7 @@ p2m_get_p2m(struct vcpu *v)
if (!nestedhvm_is_n2(v))
return p2m_get_hostp2m(v->domain);

- return p2m_get_nestedp2m(v, nhvm_vcpu_hostcr3(v));
+ return p2m_get_nestedp2m(v, nhvm_vcpu_p2m_base(v));
}

unsigned long paging_gva_to_gfn(struct vcpu *v,
@@ -1549,15 +1549,15 @@ unsigned long paging_gva_to_gfn(struct vcpu *v,
struct p2m_domain *p2m;
const struct paging_mode *mode;
uint32_t pfec_21 = *pfec;
- uint64_t ncr3 = nhvm_vcpu_hostcr3(v);
+ uint64_t np2m_base = nhvm_vcpu_p2m_base(v);

/* translate l2 guest va into l2 guest gfn */
- p2m = p2m_get_nestedp2m(v, ncr3);
+ p2m = p2m_get_nestedp2m(v, np2m_base);
mode = paging_get_nestedmode(v);
gfn = mode->gva_to_gfn(v, p2m, va, pfec);

/* translate l2 guest gfn into l1 guest gfn */
- return hostmode->p2m_ga_to_gfn(v, hostp2m, ncr3,
+ return hostmode->p2m_ga_to_gfn(v, hostp2m, np2m_base,
gfn << PAGE_SHIFT, &pfec_21, NULL);
}

diff --git a/xen/include/asm-x86/hvm/hvm.h b/xen/include/asm-x86/hvm/hvm.h
index fdb0f58..d3535b6 100644
--- a/xen/include/asm-x86/hvm/hvm.h
+++ b/xen/include/asm-x86/hvm/hvm.h
@@ -170,7 +170,7 @@ struct hvm_function_table {
uint64_t exitcode);
int (*nhvm_vcpu_vmexit_trap)(struct vcpu *v, struct hvm_trap *trap);
uint64_t (*nhvm_vcpu_guestcr3)(struct vcpu *v);
- uint64_t (*nhvm_vcpu_hostcr3)(struct vcpu *v);
+ uint64_t (*nhvm_vcpu_p2m_base)(struct vcpu *v);
uint32_t (*nhvm_vcpu_asid)(struct vcpu *v);
int (*nhvm_vmcx_guest_intercepts_trap)(struct vcpu *v,
unsigned int trapnr, int errcode);
@@ -475,7 +475,7 @@ uint64_t nhvm_vcpu_guestcr3(struct vcpu *v);
/* returns l1 guest's cr3 that points to the page table used to
* translate l2 guest physical address to l1 guest physical address.
*/
-uint64_t nhvm_vcpu_hostcr3(struct vcpu *v);
+uint64_t nhvm_vcpu_p2m_base(struct vcpu *v);
/* returns the asid number l1 guest wants to use to run the l2 guest */
uint32_t nhvm_vcpu_asid(struct vcpu *v);

diff --git a/xen/include/asm-x86/hvm/vmx/vvmx.h b/xen/include/asm-x86/hvm/vmx/vvmx.h
index dce2cd8..d97011d 100644
--- a/xen/include/asm-x86/hvm/vmx/vvmx.h
+++ b/xen/include/asm-x86/hvm/vmx/vvmx.h
@@ -99,7 +99,7 @@ int nvmx_vcpu_initialise(struct vcpu *v);
void nvmx_vcpu_destroy(struct vcpu *v);
int nvmx_vcpu_reset(struct vcpu *v);
uint64_t nvmx_vcpu_guestcr3(struct vcpu *v);
-uint64_t nvmx_vcpu_hostcr3(struct vcpu *v);
+uint64_t nvmx_vcpu_eptp_base(struct vcpu *v);
uint32_t nvmx_vcpu_asid(struct vcpu *v);
enum hvm_intblk nvmx_intr_blocked(struct vcpu *v);
int nvmx_intercepts_exception(struct vcpu *v,
diff --git a/xen/include/asm-x86/p2m.h b/xen/include/asm-x86/p2m.h
index 2bd2048..ce26594 100644
--- a/xen/include/asm-x86/p2m.h
+++ b/xen/include/asm-x86/p2m.h
@@ -197,17 +197,17 @@ struct p2m_domain {

struct domain *domain; /* back pointer to domain */

- /* Nested p2ms only: nested-CR3 value that this p2m shadows.
- * This can be cleared to CR3_EADDR under the per-p2m lock but
+ /* Nested p2ms only: nested p2m base value that this p2m shadows.
+ * This can be cleared to P2M_BASE_EADDR under the per-p2m lock but
* needs both the per-p2m lock and the per-domain nestedp2m lock
* to set it to any other value. */
-#define CR3_EADDR (~0ULL)
- uint64_t cr3;
+#define P2M_BASE_EADDR (~0ULL)
+ uint64_t np2m_base;

/* Nested p2ms: linked list of n2pms allocated to this domain.
* The host p2m hasolds the head of the list and the np2ms are
* threaded on in LRU order. */
- struct list_head np2m_list;
+ struct list_head np2m_list;

/* Host p2m: when this flag is set, don't flush all the nested-p2m
@@ -282,11 +282,11 @@ struct p2m_domain {
/* get host p2m table */
#define p2m_get_hostp2m(d) ((d)->arch.p2m)

-/* Get p2m table (re)usable for specified cr3.
+/* Get p2m table (re)usable for specified np2m base.
* Automatically destroys and re-initializes a p2m if none found.
- * If cr3 == 0 then v->arch.hvm_vcpu.guest_cr[3] is used.
+ * If np2m_base == 0 then v->arch.hvm_vcpu.guest_cr[3] is used.
*/
-struct p2m_domain *p2m_get_nestedp2m(struct vcpu *v, uint64_t cr3);
+struct p2m_domain *p2m_get_nestedp2m(struct vcpu *v, uint64_t np2m_base);

/* If vcpu is in host mode then behaviour matches p2m_get_hostp2m().
* If vcpu is in guest mode then behaviour matches p2m_get_nestedp2m().
--
1.7.1

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] test report for Xen 4.2.1 release (no replies)

Ren, Yongjie — Mon, 24 Dec 2012 17:13:59 +0800

Hi All,
We did some testing for Xen 4.2.1 RC1, RC2 and final RELEASE version on Intel SandyBridge and Westmere platforms.
We found no regression and no fixed bug in our bug tracking list.
We covered basic Windows & Linux guest bootup, live migration, power management, VT-d, SR-IOV, vCPU hot-plug features.

Xen: 4.2.1 RC1/RC2/RELEASE (xen-4.2-testing.hg tree)
Dom0: Linux 3.7.1

Best Regards,
Yongjie (Jay)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] (updated) test report for xen-unstable tree with upstream QEMU (no replies)

Ren, Yongjie — Mon, 24 Dec 2012 10:32:23 +0800

Hi All,
We did some testing for Xen-unstable tree with upstream QEMU.
We covered basic guest booting up, power management, VT-d, SR-IOV features.
We found 4 new bugs which only exist in upstream QEMU not in qemu-xen.

We followed the below wiki page to use upstream QEMU.
[wiki.xen.org]

test tree:
xen-unstable-tree.hg: C/S 26193 (about 20 days ago)
qemu.git: commit e9bff10f8db (about 20 days ago)
Dom0: Linux 3.6.9 release version.

test machine:
Intel Westmere-EP and SandyBridge-EP systems.

new bugs (which don't exist with qemu-xen-unstable tree):
1. 'maxvcpus=NUM' item is not supported in upstream QEMU
[bugzilla.xen.org]
-- This blocked vCPU hot-plug for HVM guest.
2. Guest console hangs after save/restore or live-migration when setting 'hpet=0' in guest config file
[bugzilla.xen.org]
3. 'xen_platform_pci=0' setting cannot make the guest use emulated PCI devices by default
[bugzilla.xen.org]
4. Guest free memory with upstream qemu is 14MB lower than that with qemu-xen-unstable.git
[bugzilla.xen.org]
-- This might not be a bug; we just curious to know what the additional 14MB memory is for.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] test report for xen-unstable tree with upstream QEMU (no replies)

Ren, Yongjie — Mon, 24 Dec 2012 10:24:05 +0800

Hi All,
We did some testing for Xen-unstable tree with upstream QEMU.
We covered basic guest booting up, power management, VT-d, SR-IOV features.
We found 4 new bugs which only exist in upstream QEMU not in qemu-xen.

We followed the below wiki page to use upstream QEMU.
[wiki.xen.org]

test tree:
xen-unstable-tree.hg: C/S 26193 (about 20 days ago)
qemu.git: commit e9bff10f8db (about 20 days ago)
Dom0: Linux 3.6.9 release version.

test machine:
Intel Westmere-EP and SandyBridge-EP systems.

new bugs (which don't exist with qemu-xen-unstable tree):
1. 'maxvcpus=NUM' item is not supported in upstream QEMU
[bugzilla.xen.org]
-- This blocked vCPU hot-plug for HVM guest.
2. Guest console hangs after save/restore or live-migration when setting 'hpet=0' in guest config file
[bugzilla.xen.org]
3. 'xen_platform_pci=0' setting cannot make the guest use emulated PCI devices by default
[bugzilla.xen.org]
4. Guest free memory with upstream qemu is 14MB lower than that with qemu-xen-unstable.git
[bugzilla.xen.org]
-- This might not be a bug; we just curious to know what the additional 14MB memory is for.

Best Regards,
Yongjie (Jay)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [RFC 2/8] xen_platform: do not use old_portio-style callbacks (no replies)

Hervé Poussineau — Mon, 24 Dec 2012 03:19:36 +0800

Signed-off-by: Hervé Poussineau
---
hw/xen_platform.c | 21 ++++++++++-----------
1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/hw/xen_platform.c b/hw/xen_platform.c
index a54e7a2..ad7cb06 100644
--- a/hw/xen_platform.c
+++ b/hw/xen_platform.c
@@ -280,7 +280,8 @@ static void platform_fixed_ioport_init(PCIXenPlatformState* s)

/* Xen Platform PCI Device */

-static uint32_t xen_platform_ioport_readb(void *opaque, uint32_t addr)
+static uint64_t xen_platform_ioport_readb(void *opaque, hwaddr addr,
+ unsigned int size)
{
if (addr == 0) {
return platform_fixed_ioport_readb(opaque, 0);
@@ -289,30 +290,28 @@ static uint32_t xen_platform_ioport_readb(void *opaque, uint32_t addr)
}
}

-static void xen_platform_ioport_writeb(void *opaque, uint32_t addr, uint32_t val)
+static void xen_platform_ioport_writeb(void *opaque, hwaddr addr,
+ uint64_t val, unsigned int size)
{
PCIXenPlatformState *s = opaque;

switch (addr) {
case 0: /* Platform flags */
- platform_fixed_ioport_writeb(opaque, 0, val);
+ platform_fixed_ioport_writeb(opaque, 0, (uint32_t)val);
break;
case 8:
- log_writeb(s, val);
+ log_writeb(s, (uint32_t)val);
break;
default:
break;
}
}

-static MemoryRegionPortio xen_pci_portio[] = {
- { 0, 0x100, 1, .read = xen_platform_ioport_readb, },
- { 0, 0x100, 1, .write = xen_platform_ioport_writeb, },
- PORTIO_END_OF_LIST()
-};
-
static const MemoryRegionOps xen_pci_io_ops = {
- .old_portio = xen_pci_portio,
+ .read = xen_platform_ioport_readb,
+ .write = xen_platform_ioport_writeb,
+ .impl.min_access_size = 1,
+ .impl.max_access_size = 1,
};

static void platform_ioport_bar_setup(PCIXenPlatformState *d)
--
1.7.10.4

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] Creating guest with less than 4MB RAM causes Xen to crash immediately (no replies)

Wei Liu — Sun, 23 Dec 2012 15:36:13 +0800

Keir, Tim and IanJ

When user creates a guest with less than 4MB of memory, Xen crashes
immediately. That's because:

* libxc round up memory to 4MB and build page table for the guest,
see xc_dom_x86.c:count_pgtables. So the virt_pgtab_end is at
least 0x400000.
* When Xen try to pin page table for guest, it will scan through
page table and invoke arch/x86/mm.c:get_page_type, which has a
assertion that if any error happens the rc should only be
-EINVAL, otherwise Xen crashes.
* For a guest with less than 4MB memory, some of the entries in
the page table are not valid, causing __get_page_type to fail
with -EBUSY, which causes the assertion to fail.

In practice few people will create a DomU with less than 4MB ram. I
encounter this because I was trying to boot up ~3K+ minios.

Xen console log and xl output files attached.

Wei.
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] How to use the vTPM backend driver in the pv-ops kernel (2 replies)

gavin — Sun, 23 Dec 2012 21:12:21 +0800

Hi,

I cannot find the vTPM config option CONFIG_XEN_TPMDEV_BACKEND in the config file of pv-ops kernel, such as kernel 2.6.32.50. However, this option exists in the config file of kernel version 2.6.18.8. I also cannot find the vTPM backed driver (such as linux-2.6.18-xen.hg/drivers/xen/tpmback ) in the pv-ops kernel.
So, how can I configure and use the vTPM backend driver in kernel 2.6.32?
Thank you for any advice.

Best Regards,
Gavin_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] how to run a qcow format para-virtualized machine with blktap modules used (2 replies)

hxkhust — Sat, 22 Dec 2012 23:56:39 +0800

Hi,guys,
first of all,I'm working on xen 4.1 and xen 3.4.I need your help corresponding to these two kinds of xen.
As I know ,para-virtualized machines will use blktap for their read/write and full-virtualized machines will use qemu. I have seen that there are block-qcow.c and block-qcow2.c in blktap/drives/, and I would like to use them for my VM's reading and writing.I plan to create raw-format image as bascking file image and then create qcow format images based on the raw-format one.I know it need to use para-virtualized machines.
I have tried like these:
I create a para-virtualized machine with config file in which vmlinuz and initrd are needed. when I finish the VM's os installation, I use bootloader pygrub to take the place of vmlinuz and initrd.Then I create a qcow format image based on the one created just now.but the vm could not been set up normally.
so I failed.
who could help me to create a para-virtualized machine which take a qcow format image as its virtual disk (and this qcow image is based on a backing file )?
I need your help and the deadline is coming,exactly tomorrow is my deadline.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [xen-unstable test] 14810: tolerable FAIL (no replies)

xen.org — Sat, 22 Dec 2012 18:22:06 +0800

flight 14810 xen-unstable real [real]
[www.chiark.greenend.org.uk]

Failures :-/ but no regressions.

Regressions which are regarded as allowable (not blocking):
test-amd64-amd64-xl-sedf-pin 10 guest-saverestore fail like 14807
test-amd64-amd64-xl-sedf 5 xen-boot fail like 14807

Tests which did not succeed, but are not blocking:
test-amd64-amd64-xl-pcipt-intel 9 guest-start fail never pass
test-amd64-i386-xend-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-qemut-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemuu-winxpsp3 13 guest-stop fail never pass
test-amd64-amd64-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-winxpsp3 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xend-qemut-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemut-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-qemuu-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-win 13 guest-stop fail never pass
test-amd64-amd64-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemut-win 13 guest-stop fail never pass
test-amd64-amd64-xl-qemut-winxpsp3 13 guest-stop fail never pass

version targeted for testing:
xen c4114a042410
baseline version:
xen c4114a042410

jobs:
build-amd64 pass
build-i386 pass
build-amd64-oldkern pass
build-i386-oldkern pass
build-amd64-pvops pass
build-i386-pvops pass
test-amd64-amd64-xl pass
test-amd64-i386-xl pass
test-amd64-i386-rhel6hvm-amd pass
test-amd64-i386-qemut-rhel6hvm-amd pass
test-amd64-i386-qemuu-rhel6hvm-amd pass
test-amd64-amd64-xl-qemut-win7-amd64 fail
test-amd64-i386-xl-qemut-win7-amd64 fail
test-amd64-amd64-xl-qemuu-win7-amd64 fail
test-amd64-amd64-xl-win7-amd64 fail
test-amd64-i386-xl-win7-amd64 fail
test-amd64-i386-xl-credit2 pass
test-amd64-amd64-xl-pcipt-intel fail
test-amd64-i386-rhel6hvm-intel pass
test-amd64-i386-qemut-rhel6hvm-intel pass
test-amd64-i386-qemuu-rhel6hvm-intel pass
test-amd64-i386-xl-multivcpu pass
test-amd64-amd64-pair pass
test-amd64-i386-pair pass
test-amd64-amd64-xl-sedf-pin fail
test-amd64-amd64-pv pass
test-amd64-i386-pv pass
test-amd64-amd64-xl-sedf fail
test-amd64-i386-win-vcpus1 fail
test-amd64-i386-qemut-win-vcpus1 fail
test-amd64-i386-xl-qemut-win-vcpus1 fail
test-amd64-i386-xl-win-vcpus1 fail
test-amd64-i386-xl-qemut-winxpsp3-vcpus1 fail
test-amd64-i386-xl-winxpsp3-vcpus1 fail
test-amd64-amd64-win fail
test-amd64-i386-win fail
test-amd64-amd64-qemut-win fail
test-amd64-i386-qemut-win fail
test-amd64-amd64-xl-qemut-win fail
test-amd64-amd64-xl-win fail
test-amd64-i386-xend-qemut-winxpsp3 fail
test-amd64-amd64-xl-qemut-winxpsp3 fail
test-amd64-amd64-xl-qemuu-winxpsp3 fail
test-amd64-i386-xend-winxpsp3 fail
test-amd64-amd64-xl-winxpsp3 fail

------------------------------------------------------------
sg-report-flight on woking.cam.xci-test.com
logs: /home/xc_osstest/logs
images: /home/xc_osstest/images

Logs, config files, etc. are available at
[www.chiark.greenend.org.uk]

Test harness code can be found at
[xenbits.xensource.com]

Published tested tree is already up to date.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [xen-unstable test] 14807: tolerable FAIL - PUSHED (no replies)

xen.org — Sat, 22 Dec 2012 12:31:45 +0800

flight 14807 xen-unstable real [real]
[www.chiark.greenend.org.uk]

Failures :-/ but no regressions.

Regressions which are regarded as allowable (not blocking):
test-amd64-amd64-xl-sedf-pin 10 guest-saverestore fail like 14805
test-amd64-amd64-xl-sedf 5 xen-boot fail like 14805

Tests which did not succeed, but are not blocking:
test-amd64-amd64-xl-pcipt-intel 9 guest-start fail never pass
test-amd64-i386-xend-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-qemut-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemuu-winxpsp3 13 guest-stop fail never pass
test-amd64-amd64-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-winxpsp3 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xend-qemut-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemut-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-qemuu-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-win 13 guest-stop fail never pass
test-amd64-amd64-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemut-win 13 guest-stop fail never pass
test-amd64-amd64-xl-qemut-winxpsp3 13 guest-stop fail never pass

version targeted for testing:
xen c4114a042410
baseline version:
xen 6f5c96855a9e

------------------------------------------------------------
People who touched revisions under test:
Ian Campbell
Ian Jackson
Jan Beulich
Keir Fraser
Roger Pau Monn_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [xen-unstable test] 14806: regressions - FAIL (no replies)

xen.org — Sat, 22 Dec 2012 07:17:05 +0800

flight 14806 xen-unstable real [real]
[www.chiark.greenend.org.uk]

Regressions :-(

Tests which did not succeed and are blocking,
including tests which could not be run:
test-amd64-amd64-xl-qemut-win7-amd64 7 windows-install fail REGR. vs. 14805

Regressions which are regarded as allowable (not blocking):
test-amd64-amd64-xl-sedf-pin 10 guest-saverestore fail like 14805
test-amd64-amd64-xl-sedf 5 xen-boot fail like 14805

Tests which did not succeed, but are not blocking:
test-amd64-amd64-xl-pcipt-intel 9 guest-start fail never pass
test-amd64-i386-xend-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-qemut-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemuu-winxpsp3 13 guest-stop fail never pass
test-amd64-amd64-win 16 leak-check/check fail never pass
test-amd64-i386-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win7-amd64 13 guest-stop fail never pass
test-amd64-i386-win-vcpus1 16 leak-check/check fail never pass
test-amd64-amd64-xl-winxpsp3 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-winxpsp3-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xl-qemut-win-vcpus1 13 guest-stop fail never pass
test-amd64-i386-xend-qemut-winxpsp3 16 leak-check/check fail never pass
test-amd64-i386-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-qemuu-win7-amd64 13 guest-stop fail never pass
test-amd64-amd64-xl-win 13 guest-stop fail never pass
test-amd64-amd64-qemut-win 16 leak-check/check fail never pass
test-amd64-amd64-xl-qemut-win 13 guest-stop fail never pass
test-amd64-amd64-xl-qemut-winxpsp3 13 guest-stop fail never pass

version targeted for testing:
xen c4114a042410
baseline version:
xen 6f5c96855a9e

------------------------------------------------------------
People who touched revisions under test:
Ian Campbell
Ian Jackson
Jan Beulich
Keir Fraser
Roger Pau Monn_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

Re: [Xen-devel] oopsable race in xen-gntdev (unsafe vma access) (no replies)

Konrad Rzeszutek Wilk — Sat, 22 Dec 2012 04:35:10 +0800

On Sat, Dec 15, 2012 at 06:12:11PM +0000, Al Viro wrote:
> 1) find_vma() is *not* safe without ->mmap_sem and its result may
> very well be freed just as it's returned to caller. IOW,
> gntdev_ioctl_get_offset_for_vaddr() is racy and may end up with
> dereferencing freed memory.
>
> 2) gntdev_vma_close() is putting NULL into map->vma with only
> ->mmap_sem held by caller. Things like
> if (!map->vma)
> continue;
> if (map->vma->vm_start >= end)
> continue;
> if (map->vma->vm_end <= start)
> done with just priv->lock held are racy.
>
> I'm not familiar with the code, but it looks like we need to
> protect gntdev_vma_close() guts with the same spinlock and probably
> hold ->mmap_sem shared around the "find_vma()+get to map->{index,count}"
> in the ioctl. Or replace the logics in ioctl with search through the
> list of grant_map under the same spinlock...
>
> Comments?
Hey Al,

Thank you for your analysis.

CC-ing Daniel, David and Stefano. I recall we had some priv->lock movement
in the past and there is also interaction with another piece of code -
the balloon code so we better be circumspect of not blowing up.

Al, it is around holidays and folks are mostly gone - so this will take
a bit of time to get sorted out.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [RFC] QEMU: Enabling live-migrate on HVM on qemu-xen device model in 4.2 (4 replies)

Alex Bligh — Sat, 22 Dec 2012 03:41:21 +0800

This is a COMPILE TESTED ONLY RFC for a backport of the qemu elements
of:
[marc.info]

This is a companion patchset to the libxl elements I published
here:
[marc.info]
which in turn are a backport of:
[marc.info]

Stefano: I know you said you were going to have a look at this, but
I thought I'd have a go. It compiles, which is about all I can say
for it. Feel free to throw away and redo.

Comments very welcome.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH 2/5] xen: Introduce xen_modified_memory. (no replies)

Alex Bligh — Sat, 22 Dec 2012 03:41:17 +0800

This function is to be used during live migration. Every write access to the
guest memory should call this funcion so the Xen tools knows which pages are
dirty.

Backport of 910b38e4dc4c37683c8b821e75a7f4cf095e4b21

Signed-off-by: Alex Bligh
---
hw/xen.h | 1 +
xen-all.c | 21 +++++++++++++++++++++
xen-stub.c | 4 ++++
3 files changed, 26 insertions(+), 0 deletions(-)

diff --git a/hw/xen.h b/hw/xen.h
index 2162111..359a275 100644
--- a/hw/xen.h
+++ b/hw/xen.h
@@ -45,6 +45,7 @@ void xenstore_store_pv_console_info(int i, struct CharDriverState *chr);

#if defined(NEED_CPU_H) && !defined(CONFIG_USER_ONLY)
void xen_ram_alloc(ram_addr_t ram_addr, ram_addr_t size);
+void xen_modified_memory(ram_addr_t start, ram_addr_t length);
#endif

#if defined(CONFIG_XEN) && CONFIG_XEN_CTRL_INTERFACE_VERSION < 400
diff --git a/xen-all.c b/xen-all.c
index 6b4e511..121289d 100644
--- a/xen-all.c
+++ b/xen-all.c
@@ -1135,3 +1135,24 @@ void destroy_hvm_domain(bool reboot)
xc_interface_close(xc_handle);
}
}
+
+void xen_modified_memory(ram_addr_t start, ram_addr_t length)
+{
+ if (unlikely(cpu_physical_memory_get_dirty_tracking())) {
+ int rc;
+ ram_addr_t start_pfn, nb_pages;
+
+ if (length == 0) {
+ length = TARGET_PAGE_SIZE;
+ }
+ start_pfn = start >> TARGET_PAGE_BITS;
+ nb_pages = ((start + length + TARGET_PAGE_SIZE - 1) >> TARGET_PAGE_BITS)
+ - start_pfn;
+ rc = xc_hvm_modified_memory(xen_xc, xen_domid, start_pfn, nb_pages);
+ if (rc) {
+ fprintf(stderr,
+ "%s failed for "RAM_ADDR_FMT" ("RAM_ADDR_FMT"): %i, %s\n",
+ __func__, start, nb_pages, rc, strerror(-rc));
+ }
+ }
+}
diff --git a/xen-stub.c b/xen-stub.c
index 25317ec..7b54477 100644
--- a/xen-stub.c
+++ b/xen-stub.c
@@ -48,3 +48,7 @@ int xen_init(void)
void qmp_xen_set_global_dirty_log(bool enable, Error **errp)
{
}
+
+void xen_modified_memory(ram_addr_t start, ram_addr_t length)
+{
+}
--
1.7.4.1

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 00/10] libxl: new hotplug calling convention (4 replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:11 +0800

This series implements a new hoplug calling convention for libxl.

The aim of this new convention is to reduce the blackout phase of
migration when using complex hotplug scripts, like iSCSI or other kind
of storage backends that might have a non trivial setup time.

There are some issues that I would like to discuss, the first one is
the fact that pdev_path field in libxl_device_disk is no longuer used
to store a physical path, since diskspec "target" can now contain
"random" information to connect a block device.

To solve this I would like to introduce a new field in
libxl_device_disk called "target", that will be used to store the
diskspec target parameter. This can later be copied to pdev_path if
using the old hotplug calling convention.

The second issue is related to iSCSI and iscsiadm, specifically the
way to set authentication parameters, which is done with command line
parameters or editing files (which each distro seems to place in
different locations). I will look into this to see if we can find a
suitable solution.

Thanks for the comments, Roger.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 01/10] libxl: libxl__prepare_ao_device should reset num_exec (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:08 +0800

num_exec was not cleared when calling libxl__prepare_ao_device.

Signed-off-by: Roger Pau Monné
---
tools/libxl/libxl_device.c | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)

diff --git a/tools/libxl/libxl_device.c b/tools/libxl/libxl_device.c
index 51dd06e..58d3f35 100644
--- a/tools/libxl/libxl_device.c
+++ b/tools/libxl/libxl_device.c
@@ -409,6 +409,7 @@ void libxl__prepare_ao_device(libxl__ao *ao, libxl__ao_device *aodev)
aodev->ao = ao;
aodev->rc = 0;
aodev->dev = NULL;
+ aodev->num_exec = 0;
/* Initialize timer for QEMU Bodge and hotplug execution */
libxl__ev_time_init(&aodev->timeout);
aodev->active = 1;
--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 03/10] libxl: add new "method" parameter to xl disk config (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:06 +0800

This new diskspec parameters will set script to the value passed in
method, and hotplug_version to 1.

This patch adds the basic support to handle this new scripts, by
adding the prepare/unprepare private libxl functions, and modifying
the current domain creation/destruction to call this functions at the
appropriate spots.

This patch also adds some helpers, that will be used here and in later
patches.

Signed-off-by: Roger Pau Monné
---
tools/libxl/libxl.c | 131 +++++++++++++++++++++++++++++++++++++++++-
tools/libxl/libxl_create.c | 62 +++++++++++++++++++-
tools/libxl/libxl_device.c | 80 +++++++++++++++++++------
tools/libxl/libxl_internal.h | 34 +++++++++++
tools/libxl/libxl_types.idl | 1 +
tools/libxl/libxlu_disk_l.l | 2 +
6 files changed, 288 insertions(+), 22 deletions(-)

diff --git a/tools/libxl/libxl.c b/tools/libxl/libxl.c
index 8d921bc..e141379 100644
--- a/tools/libxl/libxl.c
+++ b/tools/libxl/libxl.c
@@ -1999,6 +1999,108 @@ int libxl__device_from_disk(libxl__gc *gc, uint32_t domid,
return 0;
}

+void libxl__device_disk_prepare(libxl__egc *egc, uint32_t domid,
+ libxl_device_disk *disk,
+ libxl__ao_device *aodev)
+{
+ STATE_AO_GC(aodev->ao);
+ char *hotplug_path;
+ char *script_path;
+ int rc;
+ xs_transaction_t t = XBT_NULL;
+
+ if (disk->hotplug_version == 0) {
+ aodev->callback(egc, aodev);
+ return;
+ }
+
+ GCNEW(aodev->dev);
+ rc = libxl__device_from_disk(gc, domid, disk, aodev->dev);
+ if (rc != 0) {
+ LOG(ERROR, "Invalid or unsupported virtual disk identifier %s",
+ disk->vdev);
+ goto error;
+ }
+
+ script_path = libxl__abs_path(gc, disk->script,
+ libxl__xen_script_dir_path());
+
+ hotplug_path = libxl__device_xs_hotplug_path(gc, aodev->dev);
+ for (;;) {
+ rc = libxl__xs_transaction_start(gc, &t);
+ if (rc) goto error;
+
+ rc = libxl__xs_write_checked(gc, t,
+ GCSPRINTF("%s/params", hotplug_path),
+ disk->pdev_path);
+ if (rc)
+ goto error;
+
+ rc = libxl__xs_write_checked(gc, t,
+ GCSPRINTF("%s/script", hotplug_path),
+ script_path);
+ if (rc)
+ goto error;
+
+ rc = libxl__xs_transaction_commit(gc, &t);
+ if (!rc) break;
+ if (rc < 0) goto error;
+ }
+
+ aodev->action = DEVICE_PREPARE;
+ aodev->hotplug_version = disk->hotplug_version;
+ libxl__device_hotplug(egc, aodev);
+ return;
+
+error:
+ assert(rc);
+ libxl__xs_transaction_abort(gc, &t);
+ aodev->rc = rc;
+ aodev->callback(egc, aodev);
+ return;
+}
+
+void libxl__device_disk_unprepare(libxl__egc *egc, uint32_t domid,
+ libxl_device_disk *disk,
+ libxl__ao_device *aodev)
+{
+ STATE_AO_GC(aodev->ao);
+ char *hotplug_path;
+ int rc;
+
+ if (disk->hotplug_version == 0) {
+ aodev->callback(egc, aodev);
+ return;
+ }
+
+ GCNEW(aodev->dev);
+ rc = libxl__device_from_disk(gc, domid, disk, aodev->dev);
+ if (rc != 0) {
+ LOG(ERROR, "Invalid or unsupported virtual disk identifier %s",
+ disk->vdev);
+ goto error;
+ }
+
+ hotplug_path = libxl__device_xs_hotplug_path(gc, aodev->dev);
+ if (!libxl__xs_read(gc, XBT_NULL, hotplug_path)) {
+ LOG(DEBUG, "unable to unprepare device because %s doesn't exist",
+ hotplug_path);
+ aodev->callback(egc, aodev);
+ return;
+ }
+
+ aodev->action = DEVICE_UNPREPARE;
+ aodev->hotplug_version = disk->hotplug_version;
+ libxl__device_hotplug(egc, aodev);
+ return;
+
+error:
+ assert(rc);
+ aodev->rc = rc;
+ aodev->callback(egc, aodev);
+ return;
+}
+
/* Specific function called directly only by local disk attach,
* all other users should instead use the regular
* libxl__device_disk_add wrapper
@@ -2058,8 +2160,15 @@ static void device_disk_add(libxl__egc *egc, uint32_t domid,
dev = disk->pdev_path;

do_backend_phy:
- flexarray_append(back, "params");
- flexarray_append(back, dev);
+ if (disk->hotplug_version == 0) {
+ /*
+ * If the new hotplug version is used params is
+ * stored under a private path, since it can contain
+ * data that the guest should not see.
+ */
+ flexarray_append(back, "params");
+ flexarray_append(back, dev);
+ }

script = libxl__abs_path(gc, disk->script?: "block",
libxl__xen_script_dir_path());
@@ -2152,6 +2261,7 @@ static void device_disk_add(libxl__egc *egc, uint32_t domid,

aodev->dev = device;
aodev->action = DEVICE_CONNECT;
+ aodev->hotplug_version = disk->hotplug_version;
libxl__wait_device_connection(egc, aodev);

rc = 0;
@@ -2245,6 +2355,7 @@ int libxl_vdev_to_device_disk(libxl_ctx *ctx, uint32_t domid,
GC_INIT(ctx);
char *dompath, *path;
int devid = libxl__device_disk_dev_number(vdev, NULL, NULL);
+ libxl__device dev;
int rc = ERROR_FAIL;

if (devid < 0)
@@ -2263,6 +2374,22 @@ int libxl_vdev_to_device_disk(libxl_ctx *ctx, uint32_t domid,
goto out;

rc = libxl__device_disk_from_xs_be(gc, path, disk);
+ if (rc) {
+ LOG(ERROR, "unable to parse disk device from path %s", path);
+ goto out;
+ }
+
+ /* Check if the device is using the new hotplug interface */
+ rc = libxl__device_from_disk(gc, domid, disk, &dev);
+ if (rc) {
+ LOG(ERROR, "invalid or unsupported virtual disk identifier %s",
+ disk->vdev);
+ goto out;
+ }
+ path = libxl__device_xs_hotplug_path(gc, &dev);
+ if (libxl__xs_read(gc, XBT_NULL, path))
+ disk->hotplug_version = 1;
+
out:
GC_FREE;
return rc;
diff --git a/tools/libxl/libxl_create.c b/tools/libxl/libxl_create.c
index 9d20086..c176967 100644
--- a/tools/libxl/libxl_create.c
+++ b/tools/libxl/libxl_create.c
@@ -591,6 +591,10 @@ static int store_libxl_entry(libxl__gc *gc, uint32_t domid,
*/

/* Event callbacks, in this order: */
+
+static void domcreate_launch_bootloader(libxl__egc *egc,
+ libxl__multidev *multidev,
+ int ret);
static void domcreate_devmodel_started(libxl__egc *egc,
libxl__dm_spawn_state *dmss,
int rc);
@@ -627,6 +631,12 @@ static void domcreate_destruction_cb(libxl__egc *egc,
libxl__domain_destroy_state *dds,
int rc);

+/* If creation is not successful, this callback will be executed
+ * when devices have been unprepared */
+static void domcreate_unprepare_cb(libxl__egc *egc,
+ libxl__multidev *multidev,
+ int ret);
+
static void initiate_domain_create(libxl__egc *egc,
libxl__domain_create_state *dcs)
{
@@ -637,7 +647,6 @@ static void initiate_domain_create(libxl__egc *egc,

/* convenience aliases */
libxl_domain_config *const d_config = dcs->guest_config;
- const int restore_fd = dcs->restore_fd;
memset(&dcs->build_state, 0, sizeof(dcs->build_state));

domid = 0;
@@ -670,6 +679,33 @@ static void initiate_domain_create(libxl__egc *egc,
if (ret) goto error_out;
}

+ libxl__multidev_begin(ao, &dcs->multidev);
+ dcs->multidev.callback = domcreate_launch_bootloader;
+ libxl__prepare_disks(egc, ao, domid, d_config, &dcs->multidev);
+ libxl__multidev_prepared(egc, &dcs->multidev, 0);
+ return;
+
+error_out:
+ assert(ret);
+ domcreate_complete(egc, dcs, ret);
+}
+
+static void domcreate_launch_bootloader(libxl__egc *egc,
+ libxl__multidev *multidev,
+ int ret)
+{
+ libxl__domain_create_state *dcs = CONTAINER_OF(multidev, *dcs, multidev);
+ STATE_AO_GC(dcs->ao);
+
+ /* convenience aliases */
+ const int restore_fd = dcs->restore_fd;
+ libxl_domain_config *const d_config = dcs->guest_config;
+
+ if (ret) {
+ LOG(ERROR, "unable to prepare devices");
+ goto error_out;
+ }
+
dcs->bl.ao = ao;
libxl_device_disk *bootdisk =
d_config->num_disks > 0 ? &d_config->disks[0] : NULL;
@@ -1202,11 +1238,35 @@ static void domcreate_destruction_cb(libxl__egc *egc,
{
STATE_AO_GC(dds->ao);
libxl__domain_create_state *dcs = CONTAINER_OF(dds, *dcs, dds);
+ uint32_t domid = dcs->guest_domid;
+ libxl_domain_config *const d_config = dcs->guest_config;

if (rc)
LOG(ERROR, "unable to destroy domain %u following failed creation",
dds->domid);

+ /*
+ * We might have devices that have been prepared, but with no
+ * frontend xenstore entries, so domain destruction fails to
+ * find them, that is why we have to unprepare them manually.
+ */
+ libxl__multidev_begin(ao, &dcs->multidev);
+ dcs->multidev.callback = domcreate_unprepare_cb;
+ libxl__unprepare_disks(egc, ao, domid, d_config, &dcs->multidev);
+ libxl__multidev_prepared(egc, &dcs->multidev, 0);
+ return;
+}
+
+static void domcreate_unprepare_cb(libxl__egc *egc,
+ libxl__multidev *multidev,
+ int ret)
+{
+ libxl__domain_create_state *dcs = CONTAINER_OF(multidev, *dcs, multidev);
+ STATE_AO_GC(dcs->ao);
+
+ if (ret)
+ LOG(ERROR, "unable to unprepare devices");
+
dcs->callback(egc, dcs, ERROR_FAIL, dcs->guest_domid);
}

diff --git a/tools/libxl/libxl_device.c b/tools/libxl/libxl_device.c
index 85c9953..ce99d99 100644
--- a/tools/libxl/libxl_device.c
+++ b/tools/libxl/libxl_device.c
@@ -521,18 +521,21 @@ void libxl__multidev_prepared(libxl__egc *egc,

/******************************************************************************/

-/* Macro for defining the functions that will add a bunch of disks when
+/* Macro for defining the functions that will operate a bunch of devices when
* inside an async op with multidev.
* This macro is added to prevent repetition of code.
*
* The following functions are defined:
+ * libxl__prepare_disks
+ * libxl__unprepare_disks
* libxl__add_disks
* libxl__add_nics
* libxl__add_vtpms
*/

-#define DEFINE_DEVICES_ADD(type) \
- void libxl__add_##type##s(libxl__egc *egc, libxl__ao *ao, uint32_t domid, \
+#define DEFINE_DEVICES_FUNC(type, op) \
+ void libxl__##op##_##type##s(libxl__egc *egc, libxl__ao *ao, \
+ uint32_t domid, \
libxl_domain_config *d_config, \
libxl__multidev *multidev) \
{ \
@@ -540,16 +543,19 @@ void libxl__multidev_prepared(libxl__egc *egc,
int i; \
for (i = 0; i < d_config->num_##type##s; i++) { \
libxl__ao_device *aodev = libxl__multidev_prepare(multidev); \
- libxl__device_##type##_add(egc, domid, &d_config->type##s, \
+ libxl__device_##type##_##op(egc, domid, &d_config->type##s, \
aodev); \
} \
}

-DEFINE_DEVICES_ADD(disk)
-DEFINE_DEVICES_ADD(nic)
-DEFINE_DEVICES_ADD(vtpm)
+DEFINE_DEVICES_FUNC(disk, add)
+DEFINE_DEVICES_FUNC(nic, add)
+DEFINE_DEVICES_FUNC(vtpm, add)

-#undef DEFINE_DEVICES_ADD
+DEFINE_DEVICES_FUNC(disk, prepare)
+DEFINE_DEVICES_FUNC(disk, unprepare)
+
+#undef DEFINE_DEVICES_FUNC

/******************************************************************************/

@@ -557,6 +563,7 @@ int libxl__device_destroy(libxl__gc *gc, libxl__device *dev)
{
const char *be_path = libxl__device_backend_path(gc, dev);
const char *fe_path = libxl__device_frontend_path(gc, dev);
+ const char *hotplug_path = libxl__device_xs_hotplug_path(gc, dev);
const char *tapdisk_path = GCSPRINTF("%s/%s", be_path, "tapdisk-params");
const char *tapdisk_params;
xs_transaction_t t = 0;
@@ -572,6 +579,7 @@ int libxl__device_destroy(libxl__gc *gc, libxl__device *dev)

libxl__xs_path_cleanup(gc, t, fe_path);
libxl__xs_path_cleanup(gc, t, be_path);
+ libxl__xs_path_cleanup(gc, t, hotplug_path);

rc = libxl__xs_transaction_commit(gc, &t);
if (!rc) break;
@@ -644,6 +652,14 @@ void libxl__devices_destroy(libxl__egc *egc, libxl__devices_remove_state *drs)
continue;
}
aodev = libxl__multidev_prepare(multidev);
+ /*
+ * Check if the device has hotplug entries in xenstore,
+ * which would mean it's using the new hotplug calling
+ * convention.
+ */
+ path = libxl__device_xs_hotplug_path(gc, dev);
+ if (libxl__xs_read(gc, XBT_NULL, path))
+ aodev->hotplug_version = 1;
aodev->action = DEVICE_DISCONNECT;
aodev->dev = dev;
aodev->force = drs->force;
@@ -696,8 +712,6 @@ static void device_backend_callback(libxl__egc *egc, libxl__ev_devstate *ds,
static void device_backend_cleanup(libxl__gc *gc,
libxl__ao_device *aodev);

-static void device_hotplug(libxl__egc *egc, libxl__ao_device *aodev);
-
static void device_hotplug_timeout_cb(libxl__egc *egc, libxl__ev_time *ev,
const struct timeval *requested_abs);

@@ -732,7 +746,7 @@ void libxl__wait_device_connection(libxl__egc *egc, libxl__ao_device *aodev)
* If Qemu is running, it will set the state of the device to
* 4 directly, without waiting in state 2 for any hotplug execution.
*/
- device_hotplug(egc, aodev);
+ libxl__device_hotplug(egc, aodev);
return;
}

@@ -864,7 +878,7 @@ static void device_qemu_timeout(libxl__egc *egc, libxl__ev_time *ev,
rc = libxl__xs_write_checked(gc, XBT_NULL, state_path, "6");
if (rc) goto out;

- device_hotplug(egc, aodev);
+ libxl__device_hotplug(egc, aodev);
return;

out:
@@ -893,7 +907,7 @@ static void device_backend_callback(libxl__egc *egc, libxl__ev_devstate *ds,
goto out;
}

- device_hotplug(egc, aodev);
+ libxl__device_hotplug(egc, aodev);
return;

out:
@@ -908,7 +922,7 @@ static void device_backend_cleanup(libxl__gc *gc, libxl__ao_device *aodev)
libxl__ev_devstate_cancel(gc, &aodev->backend_ds);
}

-static void device_hotplug(libxl__egc *egc, libxl__ao_device *aodev)
+void libxl__device_hotplug(libxl__egc *egc, libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
char *be_path = libxl__device_backend_path(gc, aodev->dev);
@@ -1012,10 +1026,13 @@ static void device_hotplug_child_death_cb(libxl__egc *egc,
if (hotplug_error)
LOG(ERROR, "script: %s", hotplug_error);
aodev->rc = ERROR_FAIL;
- if (aodev->action == DEVICE_CONNECT)
+ if (aodev->action == DEVICE_CONNECT ||
+ aodev->action == DEVICE_PREPARE ||
+ aodev->action == DEVICE_LOCALATTACH)
/*
- * Only fail on device connection, on disconnection
- * ignore error, and continue with the remove process
+ * Only fail on device connection, prepare or localattach,
+ * on other cases ignore error, and continue with the remove
+ * process.
*/
goto error;
}
@@ -1025,7 +1042,7 @@ static void device_hotplug_child_death_cb(libxl__egc *egc,
* device_hotplug_done breaking the loop.
*/
aodev->num_exec++;
- device_hotplug(egc, aodev);
+ libxl__device_hotplug(egc, aodev);

return;

@@ -1041,8 +1058,33 @@ static void device_hotplug_done(libxl__egc *egc, libxl__ao_device *aodev)

device_hotplug_clean(gc, aodev);

- /* Clean xenstore if it's a disconnection */
if (aodev->action == DEVICE_DISCONNECT) {
+ switch (aodev->hotplug_version) {
+ case 0:
+ /* Clean xenstore if it's a disconnection */
+ rc = libxl__device_destroy(gc, aodev->dev);
+ if (!aodev->rc)
+ aodev->rc = rc;
+ break;
+ case 1:
+ /*
+ * Chain unprepare hotplug execution
+ * after disconnection of device.
+ */
+ aodev->num_exec = 0;
+ aodev->action = DEVICE_UNPREPARE;
+ libxl__device_hotplug(egc, aodev);
+ return;
+ default:
+ LOG(ERROR, "unknown hotplug script version (%d)",
+ aodev->hotplug_version);
+ if (!aodev->rc)
+ aodev->rc = ERROR_FAIL;
+ break;
+ }
+ }
+ /* Clean hotplug xenstore path */
+ if (aodev->action == DEVICE_UNPREPARE) {
rc = libxl__device_destroy(gc, aodev->dev);
if (!aodev->rc)
aodev->rc = rc;
diff --git a/tools/libxl/libxl_internal.h b/tools/libxl/libxl_internal.h
index c41e608..16907ff 100644
--- a/tools/libxl/libxl_internal.h
+++ b/tools/libxl/libxl_internal.h
@@ -2018,6 +2018,12 @@ struct libxl__multidev {
_hidden void libxl__device_disk_add(libxl__egc *egc, uint32_t domid,
libxl_device_disk *disk,
libxl__ao_device *aodev);
+_hidden void libxl__device_disk_prepare(libxl__egc *egc, uint32_t domid,
+ libxl_device_disk *disk,
+ libxl__ao_device *aodev);
+_hidden void libxl__device_disk_unprepare(libxl__egc *egc, uint32_t domid,
+ libxl_device_disk *disk,
+ libxl__ao_device *aodev);

/* AO operation to connect a nic device */
_hidden void libxl__device_nic_add(libxl__egc *egc, uint32_t domid,
@@ -2094,6 +2100,19 @@ _hidden int libxl__get_hotplug_script_info(libxl__gc *gc, libxl__device *dev,
libxl__device_action action,
int num_exec, int hotplug_version);

+/*
+ * libxl__device_hotplug runs the hotplug script associated
+ * with the device passed in aodev->dev.
+ *
+ * The libxl__ao_device passed to this function should be
+ * prepared using libxl__prepare_ao_device prior to calling
+ * this function.
+ *
+ * Once finished, aodev->callback will be executed.
+ */
+_hidden void libxl__device_hotplug(libxl__egc *egc,
+ libxl__ao_device *aodev);
+
/*----- local disk attach: attach a disk locally to run the bootloader -----*/

typedef struct libxl__disk_local_state libxl__disk_local_state;
@@ -2467,6 +2486,21 @@ _hidden void libxl__add_disks(libxl__egc *egc, libxl__ao *ao, uint32_t domid,
libxl_domain_config *d_config,
libxl__multidev *multidev);

+_hidden void libxl__prepare_disks(libxl__egc *egc, libxl__ao *ao,
+ uint32_t domid,
+ libxl_domain_config *d_config,
+ libxl__multidev *multidev);
+
+_hidden void libxl__prepare_undisks(libxl__egc *egc, libxl__ao *ao,
+ uint32_t domid,
+ libxl_domain_config *d_config,
+ libxl__multidev *multidev);
+
+_hidden void libxl__unprepare_disks(libxl__egc *egc, libxl__ao *ao,
+ uint32_t domid,
+ libxl_domain_config *d_config,
+ libxl__multidev *multidev);
+
_hidden void libxl__add_nics(libxl__egc *egc, libxl__ao *ao, uint32_t domid,
libxl_domain_config *d_config,
libxl__multidev *multidev);
diff --git a/tools/libxl/libxl_types.idl b/tools/libxl/libxl_types.idl
index 7eac4a8..272ff54 100644
--- a/tools/libxl/libxl_types.idl
+++ b/tools/libxl/libxl_types.idl
@@ -366,6 +366,7 @@ libxl_device_disk = Struct("device_disk", [
("removable", integer),
("readwrite", integer),
("is_cdrom", integer),
+ ("hotplug_version", integer),
])

libxl_device_nic = Struct("device_nic", [
diff --git a/tools/libxl/libxlu_disk_l.l b/tools/libxl/libxlu_disk_l.l
index bee16a1..4486c1a 100644
--- a/tools/libxl/libxlu_disk_l.l
+++ b/tools/libxl/libxlu_disk_l.l
@@ -172,6 +172,8 @@ backendtype=[^,]*,? { STRIP(','); setbackendtype(DPC,FROMEQUALS); }

vdev=[^,]*,? { STRIP(','); SAVESTRING("vdev", vdev, FROMEQUALS); }
script=[^,]*,? { STRIP(','); SAVESTRING("script", script, FROMEQUALS); }
+method=[^,]*,? { STRIP(','); SAVESTRING("script", script, FROMEQUALS);
+ DPC->disk->hotplug_version = 1; }

/* the target magic parameter, eats the rest of the string */

--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 02/10] libxl: add new hotplug interface support to hotplug script callers (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:05 +0800

Add support to call hotplug scripts that use the new hotplug interface
to the low-level functions in charge of calling hotplug scripts. This
new calling convention will be used when the hotplug_version aodev
field is 1.

Signed-off-by: Roger Pau Monné
---
tools/libxl/libxl_device.c | 33 +++++++++++++++++++-
tools/libxl/libxl_internal.h | 33 ++++++++++++++++++--
tools/libxl/libxl_linux.c | 68 ++++++++++++++++++++++++++++++++----------
tools/libxl/libxl_netbsd.c | 2 +-
4 files changed, 115 insertions(+), 21 deletions(-)

diff --git a/tools/libxl/libxl_device.c b/tools/libxl/libxl_device.c
index 58d3f35..85c9953 100644
--- a/tools/libxl/libxl_device.c
+++ b/tools/libxl/libxl_device.c
@@ -83,6 +83,35 @@ out:
return rc;
}

+char *libxl__device_hotplug_action(libxl__gc *gc,
+ libxl__device_action action)
+{
+ switch (action) {
+ case DEVICE_CONNECT:
+ return "add";
+ case DEVICE_DISCONNECT:
+ return "remove";
+ case DEVICE_PREPARE:
+ return "prepare";
+ case DEVICE_UNPREPARE:
+ return "unprepare";
+ case DEVICE_LOCALATTACH:
+ return "localattach";
+ case DEVICE_LOCALDETACH:
+ return "localdetach";
+ default:
+ LOG(ERROR, "invalid action (%d) for device", action);
+ break;
+ }
+ return NULL;
+}
+
+char *libxl__device_xs_hotplug_path(libxl__gc *gc, libxl__device *dev)
+{
+ return GCSPRINTF("/local/domain/%u/libxl/hotplug/%u/%u",
+ dev->backend_domid, dev->domid, dev->devid);
+}
+
int libxl__device_generic_add(libxl__gc *gc, xs_transaction_t t,
libxl__device *device, char **bents, char **fents)
{
@@ -410,6 +439,7 @@ void libxl__prepare_ao_device(libxl__ao *ao, libxl__ao_device *aodev)
aodev->rc = 0;
aodev->dev = NULL;
aodev->num_exec = 0;
+ aodev->hotplug_version = 0;
/* Initialize timer for QEMU Bodge and hotplug execution */
libxl__ev_time_init(&aodev->timeout);
aodev->active = 1;
@@ -891,7 +921,8 @@ static void device_hotplug(libxl__egc *egc, libxl__ao_device *aodev)
* and return the necessary args/env vars for execution */
hotplug = libxl__get_hotplug_script_info(gc, aodev->dev, &args, &env,
aodev->action,
- aodev->num_exec);
+ aodev->num_exec,
+ aodev->hotplug_version);
switch (hotplug) {
case 0:
/* no hotplug script to execute */
diff --git a/tools/libxl/libxl_internal.h b/tools/libxl/libxl_internal.h
index 0b38e3e..c41e608 100644
--- a/tools/libxl/libxl_internal.h
+++ b/tools/libxl/libxl_internal.h
@@ -1829,12 +1829,19 @@ _hidden const char *libxl__run_dir_path(void);

/*----- device addition/removal -----*/

-/* Action to perform (either connect or disconnect) */
+/* Action to perform */
typedef enum {
DEVICE_CONNECT,
- DEVICE_DISCONNECT
+ DEVICE_DISCONNECT,
+ DEVICE_PREPARE,
+ DEVICE_UNPREPARE,
+ DEVICE_LOCALATTACH,
+ DEVICE_LOCALDETACH
} libxl__device_action;

+_hidden char *libxl__device_hotplug_action(libxl__gc *gc,
+ libxl__device_action action);
+
typedef struct libxl__ao_device libxl__ao_device;
typedef struct libxl__multidev libxl__multidev;
typedef void libxl__device_callback(libxl__egc*, libxl__ao_device*);
@@ -1852,6 +1859,14 @@ typedef void libxl__device_callback(libxl__egc*, libxl__ao_device*);
* Once _prepare has been called on a libxl__ao_device, it is safe to just
* discard this struct, there's no need to call any destroy function.
* _prepare can also be called multiple times with the same libxl__ao_device.
+ *
+ * If hotplug_version field is 1, the new hotplug script calling convention
+ * will be used to call the hotplug script. This new convention provides
+ * two new actions to hotplug scripts, "prepare", "unprepare", "localattach"
+ * and "localdetach". This new actions have been added to offload work done
+ * by hotplug scripts during the blackout phase of migration. "prepare" is
+ * called before the remote domain is paused, so as much operations as
+ * possible should be done in this phase.
*/
_hidden void libxl__prepare_ao_device(libxl__ao *ao, libxl__ao_device *aodev);

@@ -1862,6 +1877,7 @@ struct libxl__ao_device {
libxl__device *dev;
int force;
libxl__device_callback *callback;
+ int hotplug_version;
/* return value, zeroed by user on entry, is valid on callback */
int rc;
/* private for multidev */
@@ -2045,6 +2061,17 @@ _hidden void libxl__initiate_device_remove(libxl__egc *egc,
libxl__ao_device *aodev);

/*
+ * libxl__device_xs_hotplug_path returns the xenstore hotplug
+ * path that is used to share information with the hotplug
+ * script.
+ *
+ * This path is only used by new hotplug scripts, that are
+ * specified using "method" instead of "script" in the disk
+ * parameters.
+ */
+_hidden char *libxl__device_xs_hotplug_path(libxl__gc *gc, libxl__device *dev);
+
+/*
* libxl__get_hotplug_script_info returns the args and env that should
* be passed to the hotplug script for the requested device.
*
@@ -2065,7 +2092,7 @@ _hidden void libxl__initiate_device_remove(libxl__egc *egc,
_hidden int libxl__get_hotplug_script_info(libxl__gc *gc, libxl__device *dev,
char ***args, char ***env,
libxl__device_action action,
- int num_exec);
+ int num_exec, int hotplug_version);

/*----- local disk attach: attach a disk locally to run the bootloader -----*/

diff --git a/tools/libxl/libxl_linux.c b/tools/libxl/libxl_linux.c
index 1fed3cd..43f23dd 100644
--- a/tools/libxl/libxl_linux.c
+++ b/tools/libxl/libxl_linux.c
@@ -190,32 +190,68 @@ out:

static int libxl__hotplug_disk(libxl__gc *gc, libxl__device *dev,
char ***args, char ***env,
- libxl__device_action action)
+ libxl__device_action action,
+ int hotplug_version)
{
char *be_path = libxl__device_backend_path(gc, dev);
- char *script;
+ char *hotplug_path = libxl__device_xs_hotplug_path(gc, dev);
+ char *script, *saction;
int nr = 0, rc = 0;
+ const int env_arraysize = 5;
+ const int arg_arraysize = 3;

- script = libxl__xs_read(gc, XBT_NULL,
- GCSPRINTF("%s/%s", be_path, "script"));
- if (!script) {
- LOGEV(ERROR, errno, "unable to read script from %s", be_path);
+ switch (hotplug_version) {
+ case 0:
+ script = libxl__xs_read(gc, XBT_NULL, GCSPRINTF("%s/script", be_path));
+ if (!script) {
+ LOGEV(ERROR, errno, "unable to read script from %s", be_path);
+ rc = ERROR_FAIL;
+ goto error;
+ }
+ *env = get_hotplug_env(gc, script, dev);
+ if (!*env) {
+ rc = ERROR_FAIL;
+ goto error;
+ }
+ break;
+ case 1:
+ /* The new hotplug calling convention only uses two ENV variables:
+ * BACKEND_PATH: path to xenstore backend of the related device.
+ * HOTPLUG_PATH: path to the xenstore directory that can be used to
+ * pass extra parameters to the script.
+ */
+ script = libxl__xs_read(gc, XBT_NULL,
+ GCSPRINTF("%s/script", hotplug_path));
+ if (!script) {
+ LOGEV(ERROR, errno, "unable to read script from %s", hotplug_path);
+ rc = ERROR_FAIL;
+ goto error;
+ }
+ GCNEW_ARRAY(*env, env_arraysize);
+ (*env)[nr++] = "BACKEND_PATH";
+ (*env)[nr++] = be_path;
+ (*env)[nr++] = "HOTPLUG_PATH";
+ (*env)[nr++] = hotplug_path;
+ (*env)[nr++] = NULL;
+ assert(nr == env_arraysize);
+ nr = 0;
+ break;
+ default:
+ LOG(ERROR, "unknown hotplug script version %d", hotplug_version);
rc = ERROR_FAIL;
goto error;
}

- *env = get_hotplug_env(gc, script, dev);
- if (!*env) {
+ GCNEW_ARRAY(*args, arg_arraysize);
+ (*args)[nr++] = script;
+ saction = libxl__device_hotplug_action(gc, action);
+ if (!saction) {
rc = ERROR_FAIL;
goto error;
}
-
- const int arraysize = 3;
- GCNEW_ARRAY(*args, arraysize);
- (*args)[nr++] = script;
- (*args)[nr++] = action == DEVICE_CONNECT ? "add" : "remove";
+ (*args)[nr++] = saction;
(*args)[nr++] = NULL;
- assert(nr == arraysize);
+ assert(nr == arg_arraysize);

rc = 1;

@@ -226,7 +262,7 @@ error:
int libxl__get_hotplug_script_info(libxl__gc *gc, libxl__device *dev,
char ***args, char ***env,
libxl__device_action action,
- int num_exec)
+ int num_exec, int hotplug_version)
{
char *disable_udev = libxl__xs_read(gc, XBT_NULL, DISABLE_UDEV_PATH);
int rc;
@@ -243,7 +279,7 @@ int libxl__get_hotplug_script_info(libxl__gc *gc, libxl__device *dev,
rc = 0;
goto out;
}
- rc = libxl__hotplug_disk(gc, dev, args, env, action);
+ rc = libxl__hotplug_disk(gc, dev, args, env, action, hotplug_version);
break;
case LIBXL__DEVICE_KIND_VIF:
/*
diff --git a/tools/libxl/libxl_netbsd.c b/tools/libxl/libxl_netbsd.c
index 9587833..8061e7a 100644
--- a/tools/libxl/libxl_netbsd.c
+++ b/tools/libxl/libxl_netbsd.c
@@ -62,7 +62,7 @@ out:
int libxl__get_hotplug_script_info(libxl__gc *gc, libxl__device *dev,
char ***args, char ***env,
libxl__device_action action,
- int num_exec)
+ int num_exec, int hotplug_version)
{
char *disable_udev = libxl__xs_read(gc, XBT_NULL, DISABLE_UDEV_PATH);
int rc;
--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 07/10] libxl: add local attach support for new hotplug scripts (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:04 +0800

Adds support for locally attaching disks that use the new hotplug
script interface, by calling the localattach/localdetach operations
and returning a block device that can be used to execute pygrub.

Signed-off-by: Roger Pau Monné
---
tools/libxl/libxl.c | 88 ++++++++++++++++++++++++++++++++++------
tools/libxl/libxl_bootloader.c | 1 +
tools/libxl/libxl_internal.h | 1 +
3 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/tools/libxl/libxl.c b/tools/libxl/libxl.c
index 29b2765..b21eefc 100644
--- a/tools/libxl/libxl.c
+++ b/tools/libxl/libxl.c
@@ -2657,6 +2657,7 @@ void libxl__device_disk_local_initiate_attach(libxl__egc *egc,
const libxl_device_disk *in_disk = dls->in_disk;
libxl_device_disk *disk = &dls->disk;
const char *blkdev_start = dls->blkdev_start;
+ uint32_t domid = dls->domid;

assert(in_disk->pdev_path);

@@ -2673,6 +2674,23 @@ void libxl__device_disk_local_initiate_attach(libxl__egc *egc,
case LIBXL_DISK_BACKEND_PHY:
LIBXL__LOG(ctx, LIBXL__LOG_DEBUG, "locally attaching PHY disk %s",
disk->pdev_path);
+ if (disk->hotplug_version != 0) {
+ disk->vdev = libxl__strdup(gc, in_disk->vdev);
+ libxl__prepare_ao_device(ao, &dls->aodev);
+ GCNEW(dls->aodev.dev);
+ rc = libxl__device_from_disk(gc, domid, disk,
+ dls->aodev.dev);
+ if (rc != 0) {
+ LOG(ERROR, "Invalid or unsupported virtual disk "
+ "identifier %s", disk->vdev);
+ goto out;
+ }
+ dls->aodev.action = DEVICE_LOCALATTACH;
+ dls->aodev.hotplug_version = disk->hotplug_version;
+ dls->aodev.callback = local_device_attach_cb;
+ libxl__device_hotplug(egc, &dls->aodev);
+ return;
+ }
dev = disk->pdev_path;
break;
case LIBXL_DISK_BACKEND_TAP:
@@ -2735,7 +2753,8 @@ static void local_device_attach_cb(libxl__egc *egc, libxl__ao_device *aodev)
{
STATE_AO_GC(aodev->ao);
libxl__disk_local_state *dls = CONTAINER_OF(aodev, *dls, aodev);
- char *dev = NULL, *be_path = NULL;
+ char *dev = NULL, *be_path = NULL, *hotplug_path;
+ const char *pdev = NULL;
int rc;
libxl__device device;
libxl_device_disk *disk = &dls->disk;
@@ -2748,20 +2767,45 @@ static void local_device_attach_cb(libxl__egc *egc, libxl__ao_device *aodev)
aodev->dev->devid);
goto out;
}
+ switch (disk->backend) {
+ case LIBXL_DISK_BACKEND_PHY:
+ /* Fetch hotplug output to obtain the block device */
+ rc = libxl__device_from_disk(gc, dls->domid, disk, &device);
+ if (rc)
+ goto out;
+ hotplug_path = libxl__device_xs_hotplug_path(gc, &device);
+ rc = libxl__xs_read_checked(gc, XBT_NULL,
+ GCSPRINTF("%s/pdev", hotplug_path),
+ &pdev);
+ if (rc)
+ goto out;
+ if (!pdev) {
+ rc = ERROR_FAIL;
+ goto out;
+ }
+ LOG(DEBUG, "attached local block device %s", pdev);
+ dls->diskpath = libxl__strdup(gc, pdev);
+ break;
+ case LIBXL_DISK_BACKEND_QDISK:
+ dev = GCSPRINTF("/dev/%s", disk->vdev);
+ LOG(DEBUG, "locally attaching qdisk %s", dev);

- dev = GCSPRINTF("/dev/%s", disk->vdev);
- LOG(DEBUG, "locally attaching qdisk %s", dev);
+ rc = libxl__device_from_disk(gc, LIBXL_TOOLSTACK_DOMID, disk, &device);
+ if (rc < 0)
+ goto out;
+ be_path = libxl__device_backend_path(gc, &device);
+ rc = libxl__wait_for_backend(gc, be_path, "4");
+ if (rc < 0)
+ goto out;

- rc = libxl__device_from_disk(gc, LIBXL_TOOLSTACK_DOMID, disk, &device);
- if (rc < 0)
- goto out;
- be_path = libxl__device_backend_path(gc, &device);
- rc = libxl__wait_for_backend(gc, be_path, "4");
- if (rc < 0)
+ if (dev != NULL)
+ dls->diskpath = libxl__strdup(gc, dev);
+ break;
+ default:
+ LOG(ERROR, "invalid disk backend for local attach callback");
+ rc = ERROR_FAIL;
goto out;
-
- if (dev != NULL)
- dls->diskpath = libxl__strdup(gc, dev);
+ }

dls->callback(egc, dls, 0);
return;
@@ -2785,11 +2829,29 @@ void libxl__device_disk_local_initiate_detach(libxl__egc *egc,
libxl_device_disk *disk = &dls->disk;
libxl__device *device;
libxl__ao_device *aodev = &dls->aodev;
+ uint32_t domid = dls->domid;
libxl__prepare_ao_device(ao, aodev);

if (!dls->diskpath) goto out;

switch (disk->backend) {
+ case LIBXL_DISK_BACKEND_PHY:
+ if (disk->hotplug_version != 0) {
+ GCNEW(aodev->dev);
+ rc = libxl__device_from_disk(gc, domid, disk,
+ aodev->dev);
+ if (rc != 0) {
+ LOG(ERROR, "Invalid or unsupported virtual disk "
+ "identifier %s", disk->vdev);
+ goto out;
+ }
+ aodev->action = DEVICE_LOCALDETACH;
+ aodev->hotplug_version = disk->hotplug_version;
+ aodev->callback = local_device_detach_cb;
+ libxl__device_hotplug(egc, aodev);
+ return;
+ }
+ break;
case LIBXL_DISK_BACKEND_QDISK:
if (disk->vdev != NULL) {
GCNEW(device);
@@ -2828,7 +2890,7 @@ static void local_device_detach_cb(libxl__egc *egc, libxl__ao_device *aodev)

if (aodev->rc) {
LOGE(ERROR, "unable to %s %s with id %u",
- aodev->action == DEVICE_CONNECT ? "add" : "remove",
+ libxl__device_hotplug_action(gc, aodev->action),
libxl__device_kind_to_string(aodev->dev->kind),
aodev->dev->devid);
goto out;
diff --git a/tools/libxl/libxl_bootloader.c b/tools/libxl/libxl_bootloader.c
index e103ee9..ff2e48c 100644
--- a/tools/libxl/libxl_bootloader.c
+++ b/tools/libxl/libxl_bootloader.c
@@ -381,6 +381,7 @@ void libxl__bootloader_run(libxl__egc *egc, libxl__bootloader_state *bl)
bl->dls.ao = ao;
bl->dls.in_disk = bl->disk;
bl->dls.blkdev_start = info->blkdev_start;
+ bl->dls.domid = domid;
bl->dls.callback = bootloader_disk_attached_cb;
libxl__device_disk_local_initiate_attach(egc, &bl->dls);
return;
diff --git a/tools/libxl/libxl_internal.h b/tools/libxl/libxl_internal.h
index 16907ff..67c56a6 100644
--- a/tools/libxl/libxl_internal.h
+++ b/tools/libxl/libxl_internal.h
@@ -2130,6 +2130,7 @@ struct libxl__disk_local_state {
libxl_device_disk disk;
const char *blkdev_start;
libxl__disk_local_state_callback *callback;
+ uint32_t domid;
/* filled by libxl__device_disk_local_initiate_attach */
char *diskpath;
/* private for implementation of local detach */
--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 08/10] libxl: add new hotplug interface support for HVM guests (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:03 +0800

Reads the results of the hotplug script execution and changes
pdev_path libxl_device_disk to point to the block device. This will be
used later when Qemu is launched.

Signed-off-by: Roger Pau Monné
---
tools/libxl/libxl_create.c | 33 +++++++++++++++++++++++++++++++++
1 files changed, 33 insertions(+), 0 deletions(-)

diff --git a/tools/libxl/libxl_create.c b/tools/libxl/libxl_create.c
index c176967..1d5410f 100644
--- a/tools/libxl/libxl_create.c
+++ b/tools/libxl/libxl_create.c
@@ -964,6 +964,10 @@ static void domcreate_launch_dm(libxl__egc *egc, libxl__multidev *multidev,
libxl__domain_create_state *dcs = CONTAINER_OF(multidev, *dcs, multidev);
STATE_AO_GC(dcs->ao);
int i;
+ char *hotplug_path;
+ const char *pdev;
+ libxl__device dev;
+ libxl_device_disk *disk;

/* convenience aliases */
const uint32_t domid = dcs->guest_domid;
@@ -975,6 +979,35 @@ static void domcreate_launch_dm(libxl__egc *egc, libxl__multidev *multidev,
goto error_out;
}

+ /*
+ * If using the new hotplug interface change disks pdev_path
+ * to point to the real physical path, so it can be used by Qemu.
+ */
+ for (i = 0; i < d_config->num_disks; i++) {
+ disk = &d_config->disks;
+ if (disk->hotplug_version != 0) {
+ /* Update pdev_path */
+ ret = libxl__device_from_disk(gc, domid, disk, &dev);
+ if (ret != 0) {
+ LOG(ERROR, "Invalid or unsupported virtual disk identifier %s",
+ disk->vdev);
+ goto error_out;
+ }
+ hotplug_path = libxl__device_xs_hotplug_path(gc, &dev);
+ ret = libxl__xs_read_checked(gc, XBT_NULL,
+ GCSPRINTF("%s/pdev", hotplug_path),
+ &pdev);
+ if (ret)
+ goto error_out;
+ if (!pdev) {
+ ret = ERROR_FAIL;
+ goto error_out;
+ }
+ free(disk->pdev_path);
+ disk->pdev_path = libxl__strdup(NOGC, pdev);
+ }
+ }
+
for (i = 0; i < d_config->b_info.num_ioports; i++) {
libxl_ioport_range *io = &d_config->b_info.ioports;

--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]

[Xen-devel] [PATCH RFC 10/10] hotplug/Linux: add iscsi block hotplug script (no replies)

Roger Pau Monne — Sat, 22 Dec 2012 01:15:02 +0800

This hotplug script has been tested with IET and NetBSD iSCSI targets,
without authentication.

Authentication parameters, including the password are passed as
parameters to iscsiadm, which is not recommended because other users
of the system can see them. This parameters could also be set by
editing a corresponding file directly, but the location of this file
seems to be different depending on the distribution used.

Signed-off-by: Roger Pau Monné
---
tools/hotplug/Linux/Makefile | 1 +
tools/hotplug/Linux/block-iscsi | 254 +++++++++++++++++++++++++++++++++++++++
2 files changed, 255 insertions(+), 0 deletions(-)
create mode 100644 tools/hotplug/Linux/block-iscsi

diff --git a/tools/hotplug/Linux/Makefile b/tools/hotplug/Linux/Makefile
index 0605559..98c7738 100644
--- a/tools/hotplug/Linux/Makefile
+++ b/tools/hotplug/Linux/Makefile
@@ -21,6 +21,7 @@ XEN_SCRIPTS += blktap
XEN_SCRIPTS += xen-hotplug-cleanup
XEN_SCRIPTS += external-device-migrate
XEN_SCRIPTS += vscsi
+XEN_SCRIPTS += block-iscsi
XEN_SCRIPT_DATA = xen-script-common.sh locking.sh logging.sh
XEN_SCRIPT_DATA += xen-hotplug-common.sh xen-network-common.sh vif-common.sh
XEN_SCRIPT_DATA += block-common.sh
diff --git a/tools/hotplug/Linux/block-iscsi b/tools/hotplug/Linux/block-iscsi
new file mode 100644
index 0000000..ddb96c5
--- /dev/null
+++ b/tools/hotplug/Linux/block-iscsi
@@ -0,0 +1,254 @@
+#!/bin/sh
+#
+# Open-iSCSI Xen block device hotplug script
+#
+# Author Roger Pau Monné
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation; version 2.1 only. with the special
+# exception on linking described in file LICENSE.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+
+remove_label()
+{
+ echo $1 | sed "s/^$"$2"$//"
+}
+
+check_tools()
+{
+ if ! type iscsiadm > /dev/null 2>&1; then
+ echo "Unable to find iscsiadm tool"
+ return 1
+ fi
+ if [ "$multipath" = "y" ] && ! type multipath > /dev/null 2>&1; then
+ echo "Unable to find multipath"
+ return 1
+ fi
+}
+
+# Sets the following global variables based on the params field passed in as
+# a parameter: iqn, portal, auth_method, user, multipath, password
+parse_target()
+{
+ # set multipath default value
+ multipath="n"
+ for param in $(echo "$1" | tr "," "\n")
+ do
+ if [ -n "$password" ]; then
+ password="$password,$param"
+ continue
+ fi
+ case $param in
+ iqn=*)
+ iqn=$(remove_label $param "iqn=")
+ ;;
+ portal=*)
+ portal=$(remove_label $param "portal=")
+ ;;
+ auth_method=*)
+ auth_method=$(remove_label $param "auth_method=")
+ ;;
+ user=*)
+ user=$(remove_label $param "user=")
+ ;;
+ multipath=*)
+ multipath=$(remove_label $param "multipath=")
+ ;;
+ password=*)
+ password=$(remove_label $param "password=")
+ ;;
+ esac
+ done
+ if [ -z "$iqn" ] || [ -z "$portal" ]; then
+ echo "iqn= and portal= are required parameters"
+ return 1
+ fi
+ if [ "$multipath" != "y" ] && [ "$multipath" != "n" ]; then
+ echo "multipath valid values are y and n, $multipath not a valid value"
+ return 1
+ fi
+ return 0
+}
+
+# Outputs the block device major:minor
+device_major_minor()
+{
+ stat -L -c %t:%T "$1"
+}
+
+# Sets $dev to point to the device associated with the value in iqn
+find_device()
+{
+ while [ ! -e /dev/disk/by-path/*"$iqn"-lun-0 ]; do
+ sleep 0.1
+ done
+ sddev=$(readlink -f /dev/disk/by-path/*"$iqn"-lun-0)
+ if [ ! -b "$sddev" ]; then
+ echo "Unable to find attached device path"
+ return 1
+ fi
+ if [ "$multipath" = "y" ]; then
+ mdev=$(multipath -ll "$sddev" | head -1 | awk '{ print $1}')
+ if [ ! -b /dev/mapper/"$mdev" ]; then
+ echo "Unable to find attached device multipath"
+ return 1
+ fi
+ dev="/dev/mapper/$mdev"
+ else
+ dev="$sddev"
+ fi
+ return 0
+}
+
+# Attaches the target $iqn in $portal and sets $dev to point to the
+# multipath device
+attach()
+{
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --login > /dev/null 2>&1
+ if [ $? -ne 0 ]; then
+ echo "Unable to connect to target"
+ return 1
+ fi
+ find_device
+ if [ $? -ne 0 ]; then
+ echo "Unable to find iSCSI device"
+ return 1
+ fi
+ return 0
+}
+
+# Discovers targets in $portal and checks that $iqn is one of those targets
+# Also sets the auth parameters to attach the device
+prepare()
+{
+ # Check if target is already opened
+ iscsiadm -m session 2>&1 | grep -q "$iqn"
+ if [ $? -eq 0 ]; then
+ echo "Device already opened"
+ return 1
+ fi
+ # Discover portal targets
+ iscsiadm -m discovery -t st -p $portal 2>&1 | grep -q "$iqn"
+ if [ $? -ne 0 ]; then
+ echo "No matching target iqn found"
+ return 1
+ fi
+ # Set auth method if necessary
+ if [ -n "$auth_method" ] || [ -n "$user" ] || [ -n "$password" ]; then
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=update --name \
+ node.session.auth.authmethod --value="$auth_method" \
+ > /dev/null 2>&1 && \
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=update --name \
+ node.session.auth.username --value="$user" \
+ > /dev/null 2>&1 && \
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=update --name \
+ node.session.auth.password --value="$password" \
+ > /dev/null 2>&1
+ if [ $? -ne 0 ]; then
+ echo "Unable to set authentication parameters"
+ return 1
+ fi
+ fi
+ return 0
+}
+
+# Attaches the device and writes xenstore backend entries to connect
+# the device
+add()
+{
+ localattach
+ if [ $? -ne 0 ]; then
+ echo "Failed to attach device"
+ return 1
+ fi
+ mm=$(device_major_minor "$dev")
+ xenstore-write "$BACKEND_PATH/physical-device" "$mm"
+ xenstore-write "$BACKEND_PATH/params" "$dev"
+ return 0
+}
+
+# Disconnects the device
+remove()
+{
+ find_device
+ if [ $? -ne 0 ]; then
+ echo "Unable to find device"
+ return 1
+ fi
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --logout > /dev/null 2>&1
+ if [ $? -ne 0 ]; then
+ echo "Unable to disconnect target"
+ return 1
+ fi
+ return 0
+}
+
+# Removes the auth params set by prepare
+unprepare()
+{
+ if [ -n "$auth_method" ] || [ -n "$user" ] || [ -n "$password" ]; then
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=delete --name \
+ node.session.auth.authmethod > /dev/null 2>&1
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=delete --name \
+ node.session.auth.username > /dev/null 2>&1
+ iscsiadm -m node --targetname "$iqn" -p "$portal" --op=delete --name \
+ node.session.auth.password > /dev/null 2>&1
+ fi
+}
+
+# Attaches the device to the current domain, and writes the resulting
+# block device to xenstore
+localattach()
+{
+ attach
+ if [ $? -ne 0 ]; then
+ echo "Failed to attach device"
+ return 1
+ fi
+ xenstore-write "$HOTPLUG_PATH/pdev" "$dev"
+ return 0
+}
+
+command=$1
+target=$(xenstore-read $HOTPLUG_PATH/params)
+
+if [ -z "$target" ]; then
+ echo "No information about the target"
+ exit 1
+fi
+
+check_tools || exit 1
+
+parse_target "$target"
+
+case $command in
+prepare)
+ prepare
+ exit $?
+ ;;
+add)
+ add
+ exit $?
+ ;;
+remove)
+ remove
+ exit $?
+ ;;
+unprepare)
+ unprepare
+ exit $?
+ ;;
+localattach)
+ localattach
+ exit $?
+ ;;
+localdetach)
+ remove
+ exit $?
+ ;;
+esac
--
1.7.7.5 (Apple Git-26)

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
[lists.xen.org]