From: "Dr. David Alan Gilbert (git)" <dgilbert@redhat.com>
To: qemu-devel@nongnu.org
Cc: aarcange@redhat.com, yamahata@private.email.ne.jp,
quintela@redhat.com, liang.z.li@intel.com, luis@cs.umu.se,
amit.shah@redhat.com, pbonzini@redhat.com,
david@gibson.dropbear.id.au
Subject: [Qemu-devel] [PATCH v7 25/42] Postcopy: Maintain sentmap and calculate discard
Date: Tue, 16 Jun 2015 11:26:38 +0100 [thread overview]
Message-ID: <1434450415-11339-26-git-send-email-dgilbert@redhat.com> (raw)
In-Reply-To: <1434450415-11339-1-git-send-email-dgilbert@redhat.com>
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
Where postcopy is preceeded by a period of precopy, the destination will
have received pages that may have been dirtied on the source after the
page was sent. The destination must throw these pages away before
starting it's CPUs.
Maintain a 'sentmap' of pages that have already been sent.
Calculate list of sent & dirty pages
Provide helpers on the destination side to discard these.
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
---
include/migration/migration.h | 12 +++
include/migration/postcopy-ram.h | 35 +++++++
include/qemu/typedefs.h | 1 +
migration/migration.c | 1 +
migration/postcopy-ram.c | 108 +++++++++++++++++++++
migration/ram.c | 203 ++++++++++++++++++++++++++++++++++++++-
migration/savevm.c | 2 -
trace-events | 5 +
8 files changed, 363 insertions(+), 4 deletions(-)
diff --git a/include/migration/migration.h b/include/migration/migration.h
index 2a22381..4c6cf95 100644
--- a/include/migration/migration.h
+++ b/include/migration/migration.h
@@ -114,6 +114,13 @@ struct MigrationState
/* Flag set once the migration has been asked to enter postcopy */
bool start_postcopy;
+
+ /* bitmap of pages that have been sent at least once
+ * only maintained and used in postcopy at the moment
+ * where it's used to send the dirtymap at the start
+ * of the postcopy phase
+ */
+ unsigned long *sentmap;
};
void process_incoming_migration(QEMUFile *f);
@@ -183,6 +190,11 @@ double xbzrle_mig_cache_miss_rate(void);
void ram_handle_compressed(void *host, uint8_t ch, uint64_t size);
void ram_debug_dump_bitmap(unsigned long *todump, bool expected);
+/* For outgoing discard bitmap */
+int ram_postcopy_send_discard_bitmap(MigrationState *ms);
+/* For incoming postcopy discard */
+int ram_discard_range(MigrationIncomingState *mis, const char *block_name,
+ uint64_t start, uint64_t end);
/**
* @migrate_add_blocker - prevent migration from proceeding
diff --git a/include/migration/postcopy-ram.h b/include/migration/postcopy-ram.h
index d81934f..1d38f76 100644
--- a/include/migration/postcopy-ram.h
+++ b/include/migration/postcopy-ram.h
@@ -16,4 +16,39 @@
/* Return true if the host supports everything we need to do postcopy-ram */
bool postcopy_ram_supported_by_host(void);
+/*
+ * Discard the contents of memory start..end inclusive.
+ * We can assume that if we've been called postcopy_ram_hosttest returned true
+ */
+int postcopy_ram_discard_range(MigrationIncomingState *mis, uint8_t *start,
+ uint8_t *end);
+
+
+/*
+ * Called at the start of each RAMBlock by the bitmap code
+ * 'offset' is the bitmap offset of the named RAMBlock in the migration
+ * bitmap.
+ * Returns a new PDS
+ */
+PostcopyDiscardState *postcopy_discard_send_init(MigrationState *ms,
+ unsigned long offset,
+ const char *name);
+
+/*
+ * Called by the bitmap code for each chunk to discard
+ * May send a discard message, may just leave it queued to
+ * be sent later
+ * 'start' and 'end' describe an inclusive range of pages in the
+ * migration bitmap in the RAM block passed to postcopy_discard_send_init
+ */
+void postcopy_discard_send_range(MigrationState *ms, PostcopyDiscardState *pds,
+ unsigned long start, unsigned long end);
+
+/*
+ * Called at the end of each RAMBlock by the bitmap code
+ * Sends any outstanding discard messages, frees the PDS
+ */
+void postcopy_discard_send_finish(MigrationState *ms,
+ PostcopyDiscardState *pds);
+
#endif
diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h
index 8403856..61b5b46 100644
--- a/include/qemu/typedefs.h
+++ b/include/qemu/typedefs.h
@@ -61,6 +61,7 @@ typedef struct PCIExpressHost PCIExpressHost;
typedef struct PCIHostState PCIHostState;
typedef struct PCMCIACardState PCMCIACardState;
typedef struct PixelFormat PixelFormat;
+typedef struct PostcopyDiscardState PostcopyDiscardState;
typedef struct PropertyInfo PropertyInfo;
typedef struct Property Property;
typedef struct QEMUBH QEMUBH;
diff --git a/migration/migration.c b/migration/migration.c
index 22be23e..180e8b9 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -22,6 +22,7 @@
#include "block/block.h"
#include "qemu/sockets.h"
#include "migration/block.h"
+#include "migration/postcopy-ram.h"
#include "qemu/thread.h"
#include "qmp-commands.h"
#include "trace.h"
diff --git a/migration/postcopy-ram.c b/migration/postcopy-ram.c
index baf83f2..9c76472 100644
--- a/migration/postcopy-ram.c
+++ b/migration/postcopy-ram.c
@@ -27,6 +27,22 @@
#include "qemu/error-report.h"
#include "trace.h"
+#define MAX_DISCARDS_PER_COMMAND 12
+
+struct PostcopyDiscardState {
+ const char *name;
+ uint64_t offset; /* Bitmap entry for the 1st bit of this RAMBlock */
+ uint16_t cur_entry;
+ /*
+ * Start and end address of a discard range; end_list points to the byte
+ * after the end of the range.
+ */
+ uint64_t start_list[MAX_DISCARDS_PER_COMMAND];
+ uint64_t end_list[MAX_DISCARDS_PER_COMMAND];
+ unsigned int nsentwords;
+ unsigned int nsentcmds;
+};
+
/* Postcopy needs to detect accesses to pages that haven't yet been copied
* across, and efficiently map new pages in, the techniques for doing this
* are target OS specific.
@@ -145,6 +161,22 @@ out:
return ret;
}
+/*
+ * Discard the contents of memory start..end inclusive.
+ * We can assume that if we've been called postcopy_ram_hosttest returned true
+ */
+int postcopy_ram_discard_range(MigrationIncomingState *mis, uint8_t *start,
+ uint8_t *end)
+{
+ trace_postcopy_ram_discard_range(start, end);
+ if (madvise(start, (end-start)+1, MADV_DONTNEED)) {
+ error_report("%s MADV_DONTNEED: %s", __func__, strerror(errno));
+ return -1;
+ }
+
+ return 0;
+}
+
#else
/* No target OS support, stubs just fail */
@@ -154,5 +186,81 @@ bool postcopy_ram_supported_by_host(void)
return false;
}
+int postcopy_ram_discard_range(MigrationIncomingState *mis, uint8_t *start,
+ uint8_t *end)
+{
+ assert(0);
+}
#endif
+/* ------------------------------------------------------------------------- */
+
+/*
+ * Called at the start of each RAMBlock by the bitmap code
+ * 'offset' is the bitmap offset of the named RAMBlock in the migration
+ * bitmap.
+ * Returns a new PDS
+ */
+PostcopyDiscardState *postcopy_discard_send_init(MigrationState *ms,
+ unsigned long offset,
+ const char *name)
+{
+ PostcopyDiscardState *res = g_try_malloc(sizeof(PostcopyDiscardState));
+
+ if (res) {
+ res->name = name;
+ res->cur_entry = 0;
+ res->nsentwords = 0;
+ res->nsentcmds = 0;
+ res->offset = offset;
+ }
+
+ return res;
+}
+
+/*
+ * Called by the bitmap code for each chunk to discard
+ * May send a discard message, may just leave it queued to
+ * be sent later
+ * 'start' and 'end' describe an inclusive range of pages in the
+ * migration bitmap in the RAM block passed to postcopy_discard_send_init
+ */
+void postcopy_discard_send_range(MigrationState *ms, PostcopyDiscardState *pds,
+ unsigned long start, unsigned long end)
+{
+ size_t tp_bits = qemu_target_page_bits();
+ /* Convert to byte offsets within the RAM block */
+ pds->start_list[pds->cur_entry] = (start - pds->offset) << tp_bits;
+ pds->end_list[pds->cur_entry] = (1 + end - pds->offset) << tp_bits;
+ pds->cur_entry++;
+ pds->nsentwords++;
+
+ if (pds->cur_entry == MAX_DISCARDS_PER_COMMAND) {
+ /* Full set, ship it! */
+ qemu_savevm_send_postcopy_ram_discard(ms->file, pds->name,
+ pds->cur_entry,
+ pds->start_list, pds->end_list);
+ pds->nsentcmds++;
+ pds->cur_entry = 0;
+ }
+}
+
+/*
+ * Called at the end of each RAMBlock by the bitmap code
+ * Sends any outstanding discard messages, frees the PDS
+ */
+void postcopy_discard_send_finish(MigrationState *ms, PostcopyDiscardState *pds)
+{
+ /* Anything unsent? */
+ if (pds->cur_entry) {
+ qemu_savevm_send_postcopy_ram_discard(ms->file, pds->name,
+ pds->cur_entry,
+ pds->start_list, pds->end_list);
+ pds->nsentcmds++;
+ }
+
+ trace_postcopy_discard_send_finish(pds->name, pds->nsentwords,
+ pds->nsentcmds);
+
+ g_free(pds);
+}
diff --git a/migration/ram.c b/migration/ram.c
index ff1a2fb..8e681f2 100644
--- a/migration/ram.c
+++ b/migration/ram.c
@@ -32,6 +32,7 @@
#include "qemu/timer.h"
#include "qemu/main-loop.h"
#include "migration/migration.h"
+#include "migration/postcopy-ram.h"
#include "exec/address-spaces.h"
#include "migration/page_cache.h"
#include "qemu/error-report.h"
@@ -494,9 +495,17 @@ static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
return 1;
}
+/* mr: The region to search for dirty pages in
+ * start: Start address (typically so we can continue from previous page)
+ * ram_addr_abs: Pointer into which to store the address of the dirty page
+ * within the global ram_addr space
+ *
+ * Returns: byte offset within memory region of the start of a dirty page
+ */
static inline
ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
- ram_addr_t start)
+ ram_addr_t start,
+ ram_addr_t *ram_addr_abs)
{
unsigned long base = mr->ram_addr >> TARGET_PAGE_BITS;
unsigned long nr = base + (start >> TARGET_PAGE_BITS);
@@ -515,6 +524,7 @@ ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
clear_bit(next, migration_bitmap);
migration_dirty_pages--;
}
+ *ram_addr_abs = next << TARGET_PAGE_BITS;
return (next - base) << TARGET_PAGE_BITS;
}
@@ -642,6 +652,19 @@ static int save_zero_page(QEMUFile *f, RAMBlock *block, ram_addr_t offset,
return pages;
}
+static RAMBlock *ram_find_block(const char *id)
+{
+ RAMBlock *block;
+
+ QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
+ if (!strcmp(id, block->idstr)) {
+ return block;
+ }
+ }
+
+ return NULL;
+}
+
/**
* ram_save_page: Send the given page to the stream
*
@@ -921,13 +944,16 @@ static int ram_find_and_save_block(QEMUFile *f, bool last_stage,
bool complete_round = false;
int pages = 0;
MemoryRegion *mr;
+ ram_addr_t dirty_ram_abs; /* Address of the start of the dirty page in
+ ram_addr_t space */
if (!block)
block = QLIST_FIRST_RCU(&ram_list.blocks);
while (true) {
mr = block->mr;
- offset = migration_bitmap_find_and_reset_dirty(mr, offset);
+ offset = migration_bitmap_find_and_reset_dirty(mr, offset,
+ &dirty_ram_abs);
if (complete_round && block == last_seen_block &&
offset >= last_offset) {
break;
@@ -958,6 +984,11 @@ static int ram_find_and_save_block(QEMUFile *f, bool last_stage,
/* if page is unmodified, continue to the next */
if (pages > 0) {
+ MigrationState *ms = migrate_get_current();
+ if (ms->sentmap) {
+ set_bit(dirty_ram_abs >> TARGET_PAGE_BITS, ms->sentmap);
+ }
+
last_sent_block = block;
break;
}
@@ -1017,12 +1048,19 @@ void free_xbzrle_decoded_buf(void)
static void migration_end(void)
{
+ MigrationState *s = migrate_get_current();
+
if (migration_bitmap) {
memory_global_dirty_log_stop();
g_free(migration_bitmap);
migration_bitmap = NULL;
}
+ if (s->sentmap) {
+ g_free(s->sentmap);
+ s->sentmap = NULL;
+ }
+
XBZRLE_cache_lock();
if (XBZRLE.cache) {
cache_fini(XBZRLE.cache);
@@ -1090,6 +1128,161 @@ void ram_debug_dump_bitmap(unsigned long *todump, bool expected)
}
}
+/* **** functions for postcopy ***** */
+
+/*
+ * Callback from postcopy_each_ram_send_discard for each RAMBlock
+ * start,end: Indexes into the bitmap for the first and last bit
+ * representing the named block
+ */
+static int postcopy_send_discard_bm_ram(MigrationState *ms,
+ PostcopyDiscardState *pds,
+ unsigned long start, unsigned long end)
+{
+ unsigned long current;
+
+ for (current = start; current <= end; ) {
+ unsigned long set = find_next_bit(ms->sentmap, end + 1, current);
+
+ if (set <= end) {
+ unsigned long zero = find_next_zero_bit(ms->sentmap,
+ end + 1, set + 1);
+
+ if (zero > end) {
+ zero = end + 1;
+ }
+ postcopy_discard_send_range(ms, pds, set, zero - 1);
+ current = zero + 1;
+ } else {
+ current = set;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Utility for the outgoing postcopy code.
+ * Calls postcopy_send_discard_bm_ram for each RAMBlock
+ * passing it bitmap indexes and name.
+ * Returns: 0 on success
+ * (qemu_ram_foreach_block ends up passing unscaled lengths
+ * which would mean postcopy code would have to deal with target page)
+ */
+static int postcopy_each_ram_send_discard(MigrationState *ms)
+{
+ struct RAMBlock *block;
+ int ret;
+
+ QLIST_FOREACH_RCU(block, &ram_list.blocks, next) {
+ unsigned long first = block->offset >> TARGET_PAGE_BITS;
+ unsigned long last = (block->offset + (block->max_length-1))
+ >> TARGET_PAGE_BITS;
+ PostcopyDiscardState *pds = postcopy_discard_send_init(ms,
+ first,
+ block->idstr);
+
+ /*
+ * Postcopy sends chunks of bitmap over the wire, but it
+ * just needs indexes at this point, avoids it having
+ * target page specific code.
+ */
+ ret = postcopy_send_discard_bm_ram(ms, pds, first, last);
+ postcopy_discard_send_finish(ms, pds);
+ if (ret) {
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * Transmit the set of pages to be discarded after precopy to the target
+ * these are pages that have been sent previously but have been dirtied
+ * Hopefully this is pretty sparse
+ */
+int ram_postcopy_send_discard_bitmap(MigrationState *ms)
+{
+ int ret;
+
+ rcu_read_lock();
+ /* This should be our last sync, the src is now paused */
+ migration_bitmap_sync();
+
+ /*
+ * Update the sentmap to be sentmap&=dirty
+ */
+ bitmap_and(ms->sentmap, ms->sentmap, migration_bitmap,
+ last_ram_offset() >> TARGET_PAGE_BITS);
+
+
+ trace_ram_postcopy_send_discard_bitmap();
+#ifdef DEBUG_POSTCOPY
+ ram_debug_dump_bitmap(ms->sentmap, false);
+#endif
+
+ ret = postcopy_each_ram_send_discard(ms);
+ rcu_read_unlock();
+
+ return ret;
+}
+
+/*
+ * At the start of the postcopy phase of migration, any now-dirty
+ * precopied pages are discarded.
+ *
+ * start..end is an inclusive byte address range within the RAMBlock
+ *
+ * Returns 0 on success.
+ */
+int ram_discard_range(MigrationIncomingState *mis,
+ const char *block_name,
+ uint64_t start, uint64_t end)
+{
+ int ret = -1;
+
+ assert(end >= start);
+
+ rcu_read_lock();
+ RAMBlock *rb = ram_find_block(block_name);
+
+ if (!rb) {
+ error_report("ram_discard_range: Failed to find block '%s'",
+ block_name);
+ goto err;
+ }
+
+ uint8_t *host_startaddr = rb->host + start;
+ uint8_t *host_endaddr;
+
+ if ((uintptr_t)host_startaddr & (qemu_host_page_size - 1)) {
+ error_report("ram_discard_range: Unaligned start address: %p",
+ host_startaddr);
+ goto err;
+ }
+
+ if (end <= rb->used_length) {
+ host_endaddr = rb->host + end;
+ if (((uintptr_t)host_endaddr + 1) & (qemu_host_page_size - 1)) {
+ error_report("ram_discard_range: Unaligned end address: %p",
+ host_endaddr);
+ goto err;
+ }
+ ret = postcopy_ram_discard_range(mis, host_startaddr, host_endaddr);
+ } else {
+ error_report("ram_discard_range: Overrun block '%s' (%" PRIu64
+ "/%" PRIu64 "/%zu)",
+ block_name, start, end, rb->used_length);
+ }
+
+err:
+ rcu_read_unlock();
+
+ return ret;
+}
+
+
/* Each of ram_save_setup, ram_save_iterate and ram_save_complete has
* long-running RCU critical section. When rcu-reclaims in the code
* start to become numerous it will be necessary to reduce the
@@ -1147,6 +1340,12 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
migration_bitmap = bitmap_new(ram_bitmap_pages);
bitmap_set(migration_bitmap, 0, ram_bitmap_pages);
+ if (migrate_postcopy_ram()) {
+ MigrationState *s = migrate_get_current();
+ s->sentmap = bitmap_new(ram_bitmap_pages);
+ bitmap_clear(s->sentmap, 0, ram_bitmap_pages);
+ }
+
/*
* Count the total number of pages used by ram blocks not including any
* gaps due to alignment or unplugs.
diff --git a/migration/savevm.c b/migration/savevm.c
index b7f17b4..e6398dd 100644
--- a/migration/savevm.c
+++ b/migration/savevm.c
@@ -1295,7 +1295,6 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
}
trace_loadvm_postcopy_ram_handle_discard_header(ramid, len);
while (len) {
- /* TODO - ram_discard_range gets added in a later patch
uint64_t start_addr, end_addr;
start_addr = qemu_get_be64(mis->file);
end_addr = qemu_get_be64(mis->file);
@@ -1305,7 +1304,6 @@ static int loadvm_postcopy_ram_handle_discard(MigrationIncomingState *mis,
if (ret) {
return ret;
}
- */
}
trace_loadvm_postcopy_ram_handle_discard_end();
diff --git a/trace-events b/trace-events
index 72e9889..5e8a120 100644
--- a/trace-events
+++ b/trace-events
@@ -1231,6 +1231,7 @@ qemu_file_fclose(void) ""
migration_bitmap_sync_start(void) ""
migration_bitmap_sync_end(uint64_t dirty_pages) "dirty_pages %" PRIu64""
migration_throttle(void) ""
+ram_postcopy_send_discard_bitmap(void) ""
# hw/display/qxl.c
disable qxl_interface_set_mm_time(int qid, uint32_t mm_time) "%d %d"
@@ -1495,6 +1496,10 @@ rdma_start_incoming_migration_after_rdma_listen(void) ""
rdma_start_outgoing_migration_after_rdma_connect(void) ""
rdma_start_outgoing_migration_after_rdma_source_init(void) ""
+# migration/postcopy-ram.c
+postcopy_discard_send_finish(const char *ramblock, int nwords, int ncmds) "%s mask words sent=%d in %d commands"
+postcopy_ram_discard_range(void *start, void *end) "%p,%p"
+
# kvm-all.c
kvm_ioctl(int type, void *arg) "type 0x%x, arg %p"
kvm_vm_ioctl(int type, void *arg) "type 0x%x, arg %p"
--
2.4.3
next prev parent reply other threads:[~2015-06-16 10:28 UTC|newest]
Thread overview: 209+ messages / expand[flat|nested] mbox.gz Atom feed top
2015-06-16 10:26 [Qemu-devel] [PATCH v7 00/42] Postcopy implementation Dr. David Alan Gilbert (git)
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 01/42] Start documenting how postcopy works Dr. David Alan Gilbert (git)
2015-06-17 11:42 ` Juan Quintela
2015-06-17 12:30 ` Dr. David Alan Gilbert
2015-06-18 7:50 ` Li, Liang Z
2015-06-18 8:10 ` Dr. David Alan Gilbert
2015-06-18 8:28 ` Paolo Bonzini
2015-06-19 17:52 ` Dr. David Alan Gilbert
2015-06-26 6:46 ` Yang Hongyang
2015-06-26 7:53 ` zhanghailiang
2015-06-26 8:00 ` Yang Hongyang
2015-06-26 8:10 ` Dr. David Alan Gilbert
2015-06-26 8:19 ` Yang Hongyang
2015-08-04 5:20 ` Amit Shah
2015-08-05 12:21 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 02/42] Provide runtime Target page information Dr. David Alan Gilbert (git)
2015-06-17 11:43 ` Juan Quintela
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 03/42] Init page sizes in qtest Dr. David Alan Gilbert (git)
2015-06-17 11:49 ` Juan Quintela
2015-07-06 6:14 ` Amit Shah
2015-08-04 5:23 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 04/42] qemu_ram_block_from_host Dr. David Alan Gilbert (git)
2015-06-17 11:54 ` Juan Quintela
2015-07-10 8:36 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 05/42] Add qemu_get_buffer_less_copy to avoid copies some of the time Dr. David Alan Gilbert (git)
2015-06-17 11:57 ` Juan Quintela
2015-06-17 12:33 ` Dr. David Alan Gilbert
2015-07-13 9:08 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 06/42] Add wrapper for setting blocking status on a QEMUFile Dr. David Alan Gilbert (git)
2015-06-17 11:59 ` Juan Quintela
2015-06-17 12:34 ` Dr. David Alan Gilbert
2015-06-17 12:57 ` Juan Quintela
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 07/42] ram_debug_dump_bitmap: Dump a migration bitmap as text Dr. David Alan Gilbert (git)
2015-06-17 12:17 ` Juan Quintela
2015-06-19 17:04 ` Dr. David Alan Gilbert
2015-07-13 10:15 ` Juan Quintela
2015-07-13 9:12 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 08/42] migrate_init: Call from savevm Dr. David Alan Gilbert (git)
2015-06-17 12:18 ` Juan Quintela
2015-07-13 9:13 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 09/42] Rename save_live_complete to save_live_complete_precopy Dr. David Alan Gilbert (git)
2015-06-17 12:20 ` Juan Quintela
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 10/42] Return path: Open a return path on QEMUFile for sockets Dr. David Alan Gilbert (git)
2015-06-17 12:23 ` Juan Quintela
2015-06-17 17:07 ` Dr. David Alan Gilbert
2015-07-13 10:12 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 11/42] Return path: socket_writev_buffer: Block even on non-blocking fd's Dr. David Alan Gilbert (git)
2015-06-17 12:28 ` Juan Quintela
2015-06-19 17:18 ` Dr. David Alan Gilbert
2015-07-13 12:37 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 12/42] Migration commands Dr. David Alan Gilbert (git)
2015-06-17 12:31 ` Juan Quintela
2015-06-19 17:38 ` Dr. David Alan Gilbert
2015-07-13 12:45 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 13/42] Return path: Control commands Dr. David Alan Gilbert (git)
2015-06-17 12:49 ` Juan Quintela
2015-06-23 18:57 ` Dr. David Alan Gilbert
2015-07-13 12:55 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 14/42] Return path: Send responses from destination to source Dr. David Alan Gilbert (git)
2015-06-17 16:30 ` Juan Quintela
2015-06-19 18:42 ` Dr. David Alan Gilbert
2015-07-01 9:29 ` Juan Quintela
2015-08-06 12:18 ` Dr. David Alan Gilbert
2015-07-15 7:31 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 15/42] Return path: Source handling of return path Dr. David Alan Gilbert (git)
2015-07-13 10:29 ` Juan Quintela
2015-08-18 10:23 ` Dr. David Alan Gilbert
2015-07-15 7:50 ` Amit Shah
2015-07-16 11:32 ` Dr. David Alan Gilbert
2015-08-05 8:06 ` zhanghailiang
2015-08-18 10:45 ` Dr. David Alan Gilbert
2015-08-18 11:29 ` zhanghailiang
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 16/42] Rework loadvm path for subloops Dr. David Alan Gilbert (git)
2015-07-13 10:33 ` Juan Quintela
2015-07-15 9:34 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 17/42] Add migration-capability boolean for postcopy-ram Dr. David Alan Gilbert (git)
2015-06-16 15:43 ` Eric Blake
2015-06-16 15:58 ` Dr. David Alan Gilbert
2015-07-15 9:39 ` Amit Shah
2015-07-13 10:35 ` Juan Quintela
2015-07-15 9:40 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 18/42] Add wrappers and handlers for sending/receiving the postcopy-ram migration messages Dr. David Alan Gilbert (git)
2015-07-13 11:02 ` Juan Quintela
2015-07-20 10:13 ` Amit Shah
2015-08-26 14:48 ` Dr. David Alan Gilbert
2015-07-20 10:06 ` Amit Shah
2015-07-27 9:55 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 19/42] MIG_CMD_PACKAGED: Send a packaged chunk of migration stream Dr. David Alan Gilbert (git)
2015-07-13 11:07 ` Juan Quintela
2015-07-21 6:11 ` Amit Shah
2015-07-27 17:28 ` Dr. David Alan Gilbert
2015-08-04 5:27 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 20/42] Modify save_live_pending for postcopy Dr. David Alan Gilbert (git)
2015-07-13 11:12 ` Juan Quintela
2015-07-31 16:13 ` Dr. David Alan Gilbert
2015-07-21 6:17 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 21/42] postcopy: OS support test Dr. David Alan Gilbert (git)
2015-07-13 11:20 ` Juan Quintela
2015-07-13 16:31 ` Dr. David Alan Gilbert
2015-07-21 7:29 ` Amit Shah
2015-07-27 17:38 ` Dr. David Alan Gilbert
2015-08-04 5:28 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 22/42] migrate_start_postcopy: Command to trigger transition to postcopy Dr. David Alan Gilbert (git)
2015-07-13 11:23 ` Juan Quintela
2015-07-13 17:13 ` Dr. David Alan Gilbert
2015-07-13 18:07 ` Juan Quintela
2015-07-21 7:40 ` Amit Shah
2015-09-24 9:59 ` Dr. David Alan Gilbert
2015-09-24 14:20 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 23/42] MIGRATION_STATUS_POSTCOPY_ACTIVE: Add new migration state Dr. David Alan Gilbert (git)
2015-07-13 11:27 ` Juan Quintela
2015-07-13 15:53 ` Dr. David Alan Gilbert
2015-07-13 16:26 ` Juan Quintela
2015-07-13 16:48 ` Dr. David Alan Gilbert
2015-07-13 18:05 ` Juan Quintela
2015-07-21 10:33 ` Amit Shah
2015-09-23 17:04 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 24/42] Add qemu_savevm_state_complete_postcopy Dr. David Alan Gilbert (git)
2015-07-13 11:35 ` Juan Quintela
2015-07-13 15:33 ` Dr. David Alan Gilbert
2015-07-21 10:42 ` Amit Shah
2015-07-27 17:58 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` Dr. David Alan Gilbert (git) [this message]
2015-07-13 11:47 ` [Qemu-devel] [PATCH v7 25/42] Postcopy: Maintain sentmap and calculate discard Juan Quintela
2015-09-15 17:01 ` Dr. David Alan Gilbert
2015-07-21 11:36 ` Amit Shah
2015-07-31 16:51 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 26/42] postcopy: Incoming initialisation Dr. David Alan Gilbert (git)
2015-07-13 12:04 ` Juan Quintela
2015-09-23 19:06 ` Dr. David Alan Gilbert
2015-07-22 6:19 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 27/42] postcopy: ram_enable_notify to switch on userfault Dr. David Alan Gilbert (git)
2015-07-13 12:10 ` Juan Quintela
2015-07-13 17:36 ` Dr. David Alan Gilbert
2015-07-23 5:22 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 28/42] Postcopy: Postcopy startup in migration thread Dr. David Alan Gilbert (git)
2015-07-13 12:56 ` Juan Quintela
2015-07-13 17:56 ` Dr. David Alan Gilbert
2015-07-13 18:09 ` Juan Quintela
2015-09-23 17:56 ` Dr. David Alan Gilbert
2015-07-23 5:53 ` Amit Shah
2015-07-23 5:55 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 29/42] Postcopy end in migration_thread Dr. David Alan Gilbert (git)
2015-07-13 13:15 ` Juan Quintela
2015-07-23 6:41 ` Amit Shah
2015-08-04 11:31 ` Dr. David Alan Gilbert
2015-07-23 6:41 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 30/42] Page request: Add MIG_RP_MSG_REQ_PAGES reverse command Dr. David Alan Gilbert (git)
2015-07-13 13:24 ` Juan Quintela
2015-08-06 14:15 ` Dr. David Alan Gilbert
2015-07-23 6:50 ` Amit Shah
2015-08-06 14:21 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 31/42] Page request: Process incoming page request Dr. David Alan Gilbert (git)
2015-07-14 9:18 ` Juan Quintela
2015-08-06 10:45 ` Dr. David Alan Gilbert
2015-10-20 10:29 ` Juan Quintela
2015-07-23 12:23 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 32/42] Page request: Consume pages off the post-copy queue Dr. David Alan Gilbert (git)
2015-07-14 9:40 ` Juan Quintela
2015-09-16 18:36 ` Dr. David Alan Gilbert
2015-07-27 6:05 ` Amit Shah
2015-09-16 18:48 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 33/42] postcopy_ram.c: place_page and helpers Dr. David Alan Gilbert (git)
2015-07-14 10:05 ` Juan Quintela
2015-07-27 6:11 ` Amit Shah
2015-09-23 16:45 ` Dr. David Alan Gilbert
2015-07-27 6:11 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 34/42] Postcopy: Use helpers to map pages during migration Dr. David Alan Gilbert (git)
2015-07-14 12:34 ` Juan Quintela
2015-07-17 17:31 ` Dr. David Alan Gilbert
2015-07-27 7:39 ` Amit Shah
2015-08-06 11:22 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 35/42] Don't sync dirty bitmaps in postcopy Dr. David Alan Gilbert (git)
2015-07-14 12:36 ` Juan Quintela
2015-07-14 13:13 ` Dr. David Alan Gilbert
2015-07-27 7:43 ` Amit Shah
2015-07-31 9:50 ` Dr. David Alan Gilbert
2015-08-04 5:46 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 36/42] Host page!=target page: Cleanup bitmaps Dr. David Alan Gilbert (git)
2015-07-14 15:01 ` Juan Quintela
2015-07-31 15:53 ` Dr. David Alan Gilbert
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 37/42] Postcopy; Handle userfault requests Dr. David Alan Gilbert (git)
2015-07-14 15:10 ` Juan Quintela
2015-07-14 15:15 ` Dr. David Alan Gilbert
2015-07-14 15:25 ` Juan Quintela
2015-07-27 14:29 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 38/42] Start up a postcopy/listener thread ready for incoming page data Dr. David Alan Gilbert (git)
2015-07-14 15:12 ` Juan Quintela
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 39/42] postcopy: Wire up loadvm_postcopy_handle_ commands Dr. David Alan Gilbert (git)
2015-07-14 15:14 ` Juan Quintela
2015-07-28 5:53 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 40/42] End of migration for postcopy Dr. David Alan Gilbert (git)
2015-07-14 15:15 ` Juan Quintela
2015-07-28 5:55 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 41/42] Disable mlock around incoming postcopy Dr. David Alan Gilbert (git)
2015-07-14 15:22 ` Juan Quintela
2015-07-28 6:02 ` Amit Shah
2015-07-28 11:32 ` Juan Quintela
2015-08-06 14:55 ` Dr. David Alan Gilbert
2015-08-07 3:05 ` zhanghailiang
2015-09-24 10:36 ` Dr. David Alan Gilbert
2015-07-28 6:02 ` Amit Shah
2015-06-16 10:26 ` [Qemu-devel] [PATCH v7 42/42] Inhibit ballooning during postcopy Dr. David Alan Gilbert (git)
2015-07-14 15:24 ` Juan Quintela
2015-07-28 6:15 ` Amit Shah
2015-07-28 9:08 ` Dr. David Alan Gilbert
2015-07-28 10:01 ` Amit Shah
2015-07-28 11:16 ` Dr. David Alan Gilbert
2015-07-28 6:21 ` [Qemu-devel] [PATCH v7 00/42] Postcopy implementation Amit Shah
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1434450415-11339-26-git-send-email-dgilbert@redhat.com \
--to=dgilbert@redhat.com \
--cc=aarcange@redhat.com \
--cc=amit.shah@redhat.com \
--cc=david@gibson.dropbear.id.au \
--cc=liang.z.li@intel.com \
--cc=luis@cs.umu.se \
--cc=pbonzini@redhat.com \
--cc=qemu-devel@nongnu.org \
--cc=quintela@redhat.com \
--cc=yamahata@private.email.ne.jp \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.