|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [RFC][PATCH 06/13] Kemari: Kemari receiver
This patch implements a program to receive an HVM guest image in Kemari
specific way. After receiving the whole guest memory first, it keeps
receiving delta of guest status. Then, after the failover, it sets up the
guest image including QEMU status as xc_restore does.
Signed-off-by: Yoshisato Yanagisawa <yanagisawa.yoshisato@xxxxxxxxxxxxx>
Signed-off-by: Yoshi Tamura <tamura.yoshiaki@xxxxxxxxxxxxx>
---
tools/libxc/xc_dom_kemari_restore.c | 709 ++++++++++++++++++++++++++++++++++++
tools/xcutils/xc_kemari_restore.c | 88 ++++
2 files changed, 797 insertions(+)
diff -r 19201eebab16 tools/libxc/xc_dom_kemari_restore.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/libxc/xc_dom_kemari_restore.c Wed Mar 04 17:04:20 2009 +0900
@@ -0,0 +1,709 @@
+/******************************************************************************
+ * xc_dom_kemari_restore.c
+ *
+ * Restore the state of a guest session for kemari.
+ *
+ * Copyright (c) 2008 Nippon Telegraph and Telephone Corporation.
+ *
+ * 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.
+ *
+ * This source code is based on xc_domain_restore.c.
+ *
+ * Copyright (c) 2003, K A Fraser.
+ * Copyright (c) 2006, Intel Corporation
+ * Copyright (c) 2007, XenSource Inc.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "xg_private.h"
+#include "xg_save_restore.h"
+#include "xc_dom.h"
+
+#include <xen/hvm/ioreq.h>
+#include <xen/hvm/params.h>
+
+/* number of pfns this guest has (i.e. number of entries in the P2M) */
+static unsigned long p2m_size;
+
+/* number of 'in use' pfns in the guest (i.e. #P2M entries with a valid mfn) */
+static unsigned long nr_pfns;
+
+/* A table mapping each PFN to its new MFN. */
+static xen_pfn_t *p2m = NULL;
+
+/* A table of P2M mappings in the current region */
+static xen_pfn_t *p2m_batch = NULL;
+
+int xc_kemari_restore(int xc_handle, int io_fd, uint32_t dom,
+ unsigned int store_evtchn, unsigned long *store_mfn,
+ unsigned int console_evtchn, unsigned long *console_mfn,
+ unsigned int hvm, unsigned int pae)
+{
+ int rc = 1, frc, i, n, m;
+ unsigned long mfn, pfn;
+ unsigned int prev_pc, this_pc;
+
+ /* The new domain's shared-info frame number. */
+ unsigned long shared_info_frame;
+
+ /* A table containing the type of each PFN (/not/ MFN!). */
+ unsigned long *pfn_type = NULL;
+
+ /* A table of MFNs to map in the current region */
+ xen_pfn_t *region_mfn = NULL;
+
+ /* Types of the pfns in the current region */
+ unsigned long region_pfn_type[MAX_BATCH_SIZE];
+
+ /* Our mapping of the current region (batch) */
+ char *region_base;
+
+ /* Magic frames in HVM guests: ioreqs and xenstore comms. */
+ uint64_t magic_pfns[3]; /* ioreq_pfn, bufioreq_pfn, store_pfn */
+
+ /* Temporary buffered memory space until all pages are read. */
+ char *tmp_region = NULL;
+
+ /* if true, go into transaction mode */
+ int kemari_transaction_mode = 0;
+
+ /* index for grant table */
+ int grant_idx = 0;
+
+ /* Callback IRQ */
+ uint64_t callback_irq = 0;
+
+ /* active and non-active id of flip buffer */
+ int info_active = 0, info_non_active = 1;
+
+ /* Buffer for holding HVM context */
+ uint8_t *hvm_buf[2] = {NULL,NULL};
+ uint32_t hvm_buf_size = 0;
+
+ /* Buffer for qemu image */
+ uint8_t *qemu_image[2] = {NULL,NULL};
+ uint32_t qemu_image_size[2] = {0,0};
+ uint32_t qemu_buff_size = 0;
+
+ /* Buffer for the EPT identity PT location. */
+ uint64_t ident_pt[2] = {0,0};
+
+
+ if ( !hvm ) {
+ ERROR("Kemari only works on HVM domain.");
+ goto out;
+ }
+
+ /* For info only */
+ nr_pfns = 0;
+
+ if ( read_exact(io_fd, &p2m_size, sizeof(unsigned long)) )
+ {
+ ERROR("read: p2m_size");
+ goto out;
+ }
+ DPRINTF("xc_kemari_restore start: p2m_size = %lx\n", p2m_size);
+
+ /* We want zeroed memory so use calloc rather than malloc. */
+ p2m = calloc(p2m_size, sizeof(xen_pfn_t));
+ pfn_type = calloc(p2m_size, sizeof(unsigned long));
+
+ region_mfn = xg_memalign(PAGE_SIZE, ROUNDUP(
+ MAX_BATCH_SIZE * sizeof(xen_pfn_t), PAGE_SHIFT));
+ p2m_batch = xg_memalign(PAGE_SIZE, ROUNDUP(
+ MAX_BATCH_SIZE * sizeof(xen_pfn_t), PAGE_SHIFT));
+
+ /* use aligned page for speed up memmove(3) */
+ tmp_region = xg_memalign(PAGE_SIZE, PAGE_SIZE * MAX_BATCH_SIZE);
+
+ if ( (p2m == NULL) || (pfn_type == NULL) ||
+ (region_mfn == NULL) || (p2m_batch == NULL) ||
+ (tmp_region == NULL) )
+ {
+ ERROR("memory alloc failed");
+ errno = ENOMEM;
+ goto out;
+ }
+
+ memset(region_mfn, 0,
+ ROUNDUP(MAX_BATCH_SIZE * sizeof(xen_pfn_t), PAGE_SHIFT));
+ memset(p2m_batch, 0,
+ ROUNDUP(MAX_BATCH_SIZE * sizeof(xen_pfn_t), PAGE_SHIFT));
+ memset(tmp_region, 0, PAGE_SIZE * MAX_BATCH_SIZE);
+
+ if ( lock_pages(region_mfn, sizeof(xen_pfn_t) * MAX_BATCH_SIZE) )
+ {
+ ERROR("Could not lock region_mfn");
+ goto out;
+ }
+
+ if ( lock_pages(p2m_batch, sizeof(xen_pfn_t) * MAX_BATCH_SIZE) )
+ {
+ ERROR("Could not lock p2m_batch");
+ goto out;
+ }
+
+ if ( lock_pages(tmp_region, sizeof(xen_pfn_t) * MAX_BATCH_SIZE) )
+ {
+ ERROR("Could not lock region_mfn");
+ goto out;
+ }
+
+ /* Get the domain's shared-info frame. */
+ if ( read_exact(io_fd, &shared_info_frame, sizeof(unsigned long)))
+ {
+ ERROR("Error when reading shared_info_frame");
+ goto out;
+ }
+ DPRINTF("xc_kemari_restore: shared_info_frame: %lx\n", shared_info_frame);
+
+ /* read HVM-specific parameters */
+ if ( read_exact(io_fd, magic_pfns, sizeof(magic_pfns)) )
+ {
+ ERROR("error reading magic page addresses");
+ goto out;
+ }
+
+ if (read_exact(io_fd, &callback_irq, sizeof(callback_irq)))
+ {
+ ERROR("error reading magic page addresses");
+ goto out;
+ }
+
+ /* Mark all PFNs as invalid; we allocate on demand */
+ for ( pfn = 0; pfn < p2m_size; pfn++ )
+ p2m[pfn] = INVALID_P2M_ENTRY;
+
+ /*
+ * Now simply read each saved frame into its new machine frame.
+ * We uncanonicalise page tables as we go.
+ */
+ prev_pc = 0;
+
+ n = m = 0;
+ for ( ; ; )
+ {
+ int num_pages;
+ int nr_mfns;
+
+ num_pages = 0;
+ for ( ; ; ) {
+ int j;
+
+ this_pc = (n * 100) / p2m_size;
+ if ( (this_pc - prev_pc) >= 5 )
+ {
+ PPRINTF("\b\b\b\b%3d%%", this_pc);
+ prev_pc = this_pc;
+ }
+
+ if ( read_exact(io_fd, &j, sizeof(int)) )
+ {
+ ERROR("Error when reading batch size");
+ goto build;
+ }
+
+ PPRINTF("batch %d\n",j);
+
+ if ( j == -3 )
+ {
+ /* Skip padding 4 bytes then read the EPT identity PT
location. */
+ if ( read_exact(io_fd, &ident_pt[info_non_active],
+ sizeof(uint32_t)) ||
+ read_exact(io_fd, &ident_pt[info_non_active],
+ sizeof(uint64_t)) )
+ {
+ ERROR("error read the address of the EPT identity map");
+ goto build;
+ }
+
+ continue;
+ }
+
+ if (j == -4)
+ {
+ uint32_t rec_size;
+ if ( read_exact(io_fd, &rec_size, sizeof(uint32_t)) )
+ {
+ ERROR("error read the qemu file size");
+ goto build;
+ }
+
+ if (qemu_buff_size < rec_size)
+ {
+ qemu_buff_size = rec_size;
+ qemu_image[0] = realloc(qemu_image[0], qemu_buff_size);
+ qemu_image[1] = realloc(qemu_image[1], qemu_buff_size);
+ if ((qemu_image[0] == NULL) || (qemu_image[1] == NULL))
+ {
+ ERROR("error allocate memory");
+ goto out;
+ }
+ }
+
+ qemu_image_size[info_non_active] = rec_size;
+ if ( read_exact(io_fd, qemu_image[info_non_active],
+ qemu_image_size[info_non_active]) )
+ {
+ ERROR("error read the qemu image file");
+ goto build;
+ }
+
+ continue;
+ }
+
+ if ( j == 0 )
+ break; /* our work here is done */
+
+ /* j > 0: Read pages here */
+ if ( (j > MAX_BATCH_SIZE) || (j < 0) )
+ {
+ ERROR("Max batch size exceeded. Giving up. %d", j);
+ goto out;
+ }
+
+ if ( read_exact(io_fd, region_pfn_type, j*sizeof(unsigned long)) )
+ {
+ ERROR("Error when reading region pfn types");
+ goto build;
+ }
+
+ if (kemari_transaction_mode) {
+ if (num_pages != 0)
+ {
+ ERROR("Sorry! You cannot execute page-send-phase "
+ "twice. We will fix this bug in the future.");
+ DPRINTF("Sorry\n");
+ goto out;
+ }
+ num_pages = j;
+
+ /* Since there are not invalid pages, we don't need to skip */
+ if ( read_exact(io_fd, tmp_region, PAGE_SIZE * num_pages) )
+ {
+ ERROR("Error when reading page at kemari transaction
mode");
+ goto build;
+ }
+
+ continue;
+ }
+
+ /* Normal mode */
+ /* First pass for this batch: work out how much memory to alloc */
+ nr_mfns = 0;
+ for ( i = 0; i < j; i++ )
+ {
+ unsigned long pfn, pagetype;
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( (pagetype != XEN_DOMCTL_PFINFO_XTAB) &&
+ (p2m[pfn] == INVALID_P2M_ENTRY) )
+ {
+ /* Have a live PFN which hasn't had an MFN allocated */
+ p2m_batch[nr_mfns++] = pfn;
+ p2m[pfn]--;
+ }
+ }
+
+ /* Now allocate a bunch of mfns for this batch */
+ if ( nr_mfns &&
+ (xc_domain_memory_populate_physmap(xc_handle, dom, nr_mfns, 0,
+ 0, p2m_batch) != 0) )
+ {
+ ERROR("Failed to allocate memory for batch.! %d\n", nr_mfns);
+ for (i = 0; i < nr_mfns; i++)
+ DPRINTF("p2m_batch[%d] = %lx\n", i, p2m_batch[i]);
+ errno = ENOMEM;
+ goto out;
+ }
+
+ /* set special pages */
+ {
+ struct xen_add_to_physmap xatp;
+ for (i = 0; i < nr_mfns; i++)
+ if (p2m_batch[i] == shared_info_frame) {
+ xatp.domid = dom;
+ xatp.space = XENMAPSPACE_shared_info;
+ xatp.idx = 0;
+ xatp.gpfn = shared_info_frame;
+ DPRINTF("setting up shared_info_frame: %lu\n",
+ shared_info_frame);
+ if (xc_memory_op(xc_handle, XENMEM_add_to_physmap, &xatp)
+ != 0)
+ {
+ ERROR("Error setting shared_info_frame");
+ goto out;
+ }
+ } else if ((p2m_batch[i] > shared_info_frame)
+ && (p2m_batch[i] <= shared_info_frame + 32)) {
+ xatp.domid = dom;
+ xatp.space = XENMAPSPACE_grant_table;
+ xatp.idx = grant_idx;
+ xatp.gpfn = p2m_batch[i];
+ DPRINTF("grant[%d]: %lu\n", grant_idx, xatp.gpfn);
+ if (xc_memory_op(xc_handle, XENMEM_add_to_physmap,
+ &xatp) != 0)
+ {
+ PERROR("Cannot map grant table pfn: %lu", xatp.gpfn);
+ goto out;
+ }
+ grant_idx++;
+ }
+ }
+
+ /* Second pass for this batch: update p2m[] and region_mfn[] */
+ nr_mfns = 0;
+ for ( i = 0; i < j; i++ )
+ {
+ unsigned long pfn, pagetype;
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( pagetype == XEN_DOMCTL_PFINFO_XTAB )
+ region_mfn[i] = ~0UL; /* map will fail but we don't care */
+ else
+ {
+ if ( p2m[pfn] == (INVALID_P2M_ENTRY-1) )
+ {
+ /* We just allocated a new mfn above; update p2m */
+ p2m[pfn] = p2m_batch[nr_mfns++];
+ nr_pfns++;
+ }
+
+ /* setup region_mfn[] for batch map.
+ * For HVM guests, this interface takes PFNs, not MFNs */
+ region_mfn[i] = pfn;
+ }
+ }
+
+ /* Map relevant mfns */
+ region_base = xc_map_foreign_batch(
+ xc_handle, dom, PROT_WRITE, region_mfn, j);
+
+ if ( region_base == NULL )
+ {
+ ERROR("map batch failed");
+ goto out;
+ }
+
+ for ( i = 0; i < j; i++ )
+ {
+ void *page;
+ unsigned long pagetype;
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( pagetype == XEN_DOMCTL_PFINFO_XTAB )
+ /* a bogus/unmapped page: skip it */
+ continue;
+
+ if ( pfn > p2m_size )
+ {
+ ERROR("pfn out of range");
+ goto out;
+ }
+
+ pfn_type[pfn] = pagetype;
+
+ mfn = p2m[pfn];
+
+ page = region_base + i*PAGE_SIZE;
+
+ if ( read_exact(io_fd, page, PAGE_SIZE) )
+ {
+ ERROR("Error when reading page (type was %lx)", pagetype);
+ goto out;
+ }
+
+ pagetype &= XEN_DOMCTL_PFINFO_LTABTYPE_MASK;
+
+ if ( (pagetype >= XEN_DOMCTL_PFINFO_L1TAB) &&
+ (pagetype <= XEN_DOMCTL_PFINFO_L4TAB) )
+ {
+ DPRINTF("uncanonicalize_pagetable pagetype = %lx pfn =
%lu\n", pagetype, pfn);
+ }
+ else if ( pagetype != XEN_DOMCTL_PFINFO_NOTAB )
+ {
+ ERROR("Bogus page type %lx page table is out of range: "
+ "i=%d p2m_size=%lu", pagetype, i, p2m_size);
+ goto out;
+
+ }
+ } /* end of 'batch' for loop */
+
+ munmap(region_base, j*PAGE_SIZE);
+ n+= j; /* crude stats */
+ }
+
+ /* HVM specific */
+ {
+ uint32_t rec_len;
+
+ /* Read HVM context */
+ if ( read_exact(io_fd, &rec_len, sizeof(uint32_t)) )
+ {
+ ERROR("error read hvm context size!\n");
+ goto build;
+ }
+
+ if (rec_len != hvm_buf_size)
+ {
+ if (hvm_buf[info_non_active] == NULL)
+ { /* hvm_buf will be reused. */
+ hvm_buf_size = rec_len;
+ hvm_buf[0] = malloc(hvm_buf_size);
+ hvm_buf[1] = malloc(hvm_buf_size);
+ if ( hvm_buf[0] == NULL || hvm_buf[1] == NULL)
+ {
+ ERROR("memory alloc for hvm context buffer failed");
+ errno = ENOMEM;
+ goto out;
+ }
+ } else {
+ ERROR("Sorry, we did not thought about HVM image size "
+ "change.");
+ goto out;
+ }
+ }
+
+ if ( read_exact(io_fd, hvm_buf[info_non_active], hvm_buf_size) )
+ {
+ ERROR("error loading the HVM context");
+ goto build;
+ }
+ }
+
+ /*
+ * Commit!
+ */
+ {
+ int zero = 0;
+
+ if ( write_exact(io_fd, &zero, sizeof(int))) {
+ ERROR("Error when replying to sender (errno %d)", errno);
+ goto out;
+ }
+ }
+
+ /* commit pages */
+ if (kemari_transaction_mode && num_pages > 0)
+ {
+ int nr_mfns;
+ /* First pass for this batch: work out how much memory to alloc */
+ nr_mfns = 0;
+ for ( i = 0; i < num_pages; i++ )
+ {
+ unsigned long pfn, pagetype;
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( (pagetype != XEN_DOMCTL_PFINFO_XTAB) &&
+ (p2m[pfn] == INVALID_P2M_ENTRY) )
+ {
+ /* Have a live PFN which hasn't had an MFN allocated */
+ p2m_batch[nr_mfns++] = pfn;
+ p2m[pfn]--;
+ DPRINTF("Cannot be occur!!! no map for pfn: %lu\n", pfn);
+ }
+ }
+
+ /* Now allocate a bunch of mfns for this batch */
+ if ( nr_mfns &&
+ (xc_domain_memory_populate_physmap(xc_handle, dom, nr_mfns, 0,
+ 0, p2m_batch) != 0) )
+ {
+ ERROR("Failed to allocate memory for batch.!\n");
+ errno = ENOMEM;
+ goto out;
+ }
+
+ /* Second pass for this batch: update p2m[] and region_mfn[] */
+ nr_mfns = 0;
+ for ( i = 0; i < num_pages; i++ )
+ {
+ unsigned long pfn, pagetype;
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( pagetype == XEN_DOMCTL_PFINFO_XTAB ) {
+ DPRINTF("pfn %lu = XEN_DOMCTL_PFINFO_XTAB\n", pfn);
+ region_mfn[i] = ~0UL; /* map will fail but we don't care */
+ }
+ else
+ {
+ if ( p2m[pfn] == (INVALID_P2M_ENTRY-1) )
+ {
+ /* We just allocated a new mfn above; update p2m */
+ p2m[pfn] = p2m_batch[nr_mfns++];
+ nr_pfns++;
+ }
+
+ /* setup region_mfn[] for batch map.
+ * For HVM guests, this interface takes PFNs, not MFNs */
+ region_mfn[i] = pfn;
+ }
+ }
+
+ /* Map relevant mfns */
+ region_base = xc_map_foreign_batch(
+ xc_handle, dom, PROT_WRITE, region_mfn, num_pages);
+
+ if ( region_base == NULL )
+ {
+ ERROR("map batch failed");
+ goto out;
+ }
+
+ for ( i = 0; i < num_pages; i++ )
+ {
+ void *page, *spage;
+ unsigned long pagetype;
+
+ pfn = region_pfn_type[i] & ~XEN_DOMCTL_PFINFO_LTAB_MASK;
+ pagetype = region_pfn_type[i] & XEN_DOMCTL_PFINFO_LTAB_MASK;
+
+ if ( pfn > p2m_size )
+ {
+ ERROR("pfn out of range");
+ goto out;
+ }
+
+ pfn_type[pfn] = pagetype;
+
+ mfn = p2m[pfn];
+
+ page = region_base + i*PAGE_SIZE;
+ spage = tmp_region + i*PAGE_SIZE;
+
+ if ( !memmove(page, spage, PAGE_SIZE) )
+ {
+ ERROR("Error when reading page (type was %lx)", pagetype);
+ goto out;
+ }
+
+ } /* end of 'batch' for loop */
+
+ munmap(region_base, num_pages*PAGE_SIZE);
+ num_pages = 0; /* clear num_pages for refill */
+ }
+
+ /* commit HVM specific status */
+ info_active = info_non_active;
+ info_non_active = info_active ? 0 : 1;
+
+ /* HVM success! */
+ rc = 0;
+ kemari_transaction_mode = 1;
+ }
+
+ build: /* building HVM context */
+ DPRINTF("building status %d\n", rc);
+ if (rc == 0)
+ {
+ FILE *qemu_fp;
+ char path[128];
+
+ /* set the EPT identity PT location */
+ xc_set_hvm_param(xc_handle, dom, HVM_PARAM_IDENT_PT,
+ ident_pt[info_active]);
+
+ if ( (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_IOREQ_PFN, magic_pfns[0]))
+ || (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_BUFIOREQ_PFN, magic_pfns[1]))
+ || (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_STORE_PFN, magic_pfns[2]))
+ || (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_PAE_ENABLED, pae))
+ || (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_STORE_EVTCHN,
+ store_evtchn))
+ || (frc = xc_set_hvm_param(xc_handle, dom,
+ HVM_PARAM_CALLBACK_IRQ,
+ callback_irq)) )
+ {
+ ERROR("error setting HVM params: %i", frc);
+ rc = 3;
+ goto out;
+ }
+ *store_mfn = magic_pfns[2];
+ DPRINTF("kemari_restore: magic_pfns 0: %lld, 1: %lld, 2: %lld\n",
+ magic_pfns[0], magic_pfns[1], magic_pfns[2]);
+
+ frc = xc_domain_hvm_setcontext(xc_handle, dom, hvm_buf[info_active],
+ hvm_buf_size);
+ if ( frc )
+ {
+ ERROR("error setting the HVM context");
+ rc = 4;
+ goto out;
+ }
+
+ if (qemu_image_size[info_active] == 0)
+ {
+ ERROR("Did not received QEMU image");
+ rc = 5;
+ goto out;
+ }
+ snprintf(path, sizeof(path), "/var/lib/xen/qemu-save.%d", dom);
+ if ((qemu_fp = fopen(path, "w")) == NULL)
+ {
+ ERROR("error opening QEMU image");
+ rc = 5;
+ goto out;
+ }
+ if (fwrite(qemu_image[info_active], qemu_image_size[info_active],
+ 1, qemu_fp) != 1)
+ {
+ ERROR("error writing QEMU image");
+ rc = 5;
+ goto out;
+ }
+ fclose(qemu_fp);
+ }
+
+ out:
+ if ( (rc != 0) && (dom != 0) )
+ xc_domain_destroy(xc_handle, dom);
+ free(p2m);
+ free(pfn_type);
+ free(region_mfn);
+ free(p2m_batch);
+ free(tmp_region);
+ free(hvm_buf[0]);
+ free(hvm_buf[1]);
+ free(qemu_image[0]);
+ free(qemu_image[1]);
+
+ /* discard cache for save file */
+ discard_file_cache(io_fd, 1 /*flush*/);
+
+ DPRINTF("Restore exit with rc=%d\n", rc);
+
+ return rc;
+}
+
+/*
+ * Local variables:
+ * mode: C
+ * c-set-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
+
diff -r 19201eebab16 tools/xcutils/xc_kemari_restore.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/xcutils/xc_kemari_restore.c Wed Mar 04 17:04:25 2009 +0900
@@ -0,0 +1,88 @@
+/*
+ * xc_kemari_restore.c
+ *
+ * Restore the state of a running Linux session.
+ *
+ * Copyright (c) 2008 Nippon Telegraph and Telephone Corporation.
+ *
+ * This file is subject to the terms and conditions of the GNU General
+ * Public License. See the file "COPYING" in the main directory of
+ * this archive for more details.
+ *
+ * This source code is based on xc_restore.c.
+ *
+ * Copyright (C) 2005 by Christian Limpach
+ *
+ */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <err.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <xenctrl.h>
+#include <xenguest.h>
+#include <xc_private.h>
+
+static int io_fd;
+
+static void close_handler(int sig_type)
+{
+ /* let xc_kemari_restore move build process */
+ close(io_fd);
+}
+
+int
+main(int argc, char **argv)
+{
+ unsigned int domid, store_evtchn, console_evtchn;
+ unsigned int hvm, pae, apic;
+ int xc_fd, ret, one = 1;
+ unsigned long store_mfn, console_mfn;
+ struct sigaction act;
+
+ if ( argc != 8 )
+ errx(1, "usage: %s iofd domid store_evtchn "
+ "console_evtchn hvm pae apic", argv[0]);
+
+ xc_fd = xc_interface_open();
+ if ( xc_fd < 0 )
+ errx(1, "failed to open control interface");
+
+ io_fd = atoi(argv[1]);
+ domid = atoi(argv[2]);
+ store_evtchn = atoi(argv[3]);
+ console_evtchn = atoi(argv[4]);
+ hvm = atoi(argv[5]);
+ pae = atoi(argv[6]);
+ apic = atoi(argv[7]);
+
+ act.sa_handler = close_handler;
+ sigemptyset(&act.sa_mask);
+ act.sa_flags = 0;
+ sigaction(SIGHUP, &act, 0);
+ sigaction(SIGINT, &act, 0);
+
+ if ( setsockopt(io_fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0 )
+ DPRINTF("failed to set TCP_NODELAY");
+
+ ret = xc_kemari_restore(xc_fd, io_fd, domid, store_evtchn, &store_mfn,
+ console_evtchn, &console_mfn, hvm, pae);
+
+ if ( ret == 0 )
+ {
+ printf("store-mfn %li\n", store_mfn);
+ if ( !hvm )
+ printf("console-mfn %li\n", console_mfn);
+ fflush(stdout);
+ }
+
+ xc_interface_close(xc_fd);
+
+ return ret;
+}
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |