[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v3 28/47] Postcopy page-map-incoming (PMI) structure
From: |
Dr. David Alan Gilbert (git) |
Subject: |
[Qemu-devel] [PATCH v3 28/47] Postcopy page-map-incoming (PMI) structure |
Date: |
Thu, 28 Aug 2014 16:03:45 +0100 |
From: "Dr. David Alan Gilbert" <address@hidden>
The PMI holds the state of each page on the incoming side,
so that we can tell if the page is missing, already received
or there is a request outstanding for it.
Signed-off-by: Dr. David Alan Gilbert <address@hidden>
---
include/migration/migration.h | 18 +++++
include/migration/postcopy-ram.h | 10 +++
include/qemu/typedefs.h | 1 +
postcopy-ram.c | 144 +++++++++++++++++++++++++++++++++++++++
4 files changed, 173 insertions(+)
diff --git a/include/migration/migration.h b/include/migration/migration.h
index d307d1c..b6e8cda 100644
--- a/include/migration/migration.h
+++ b/include/migration/migration.h
@@ -57,6 +57,23 @@ struct MigrationRetPathState {
typedef struct MigrationState MigrationState;
+/* Postcopy page-map-incoming - data about each page on the inbound side */
+
+typedef enum {
+ POSTCOPY_PMI_MISSING, /* page hasn't yet been received */
+ POSTCOPY_PMI_REQUESTED, /* Kernel asked for a page, but we've not got it */
+ POSTCOPY_PMI_RECEIVED /* We've got the page */
+} PostcopyPMIState;
+
+struct PostcopyPMI {
+ /* TODO: I'm expecting to rework this using some atomic compare-exchange
+ * thing, which will require merging the maps together
+ */
+ QemuMutex mutex;
+ unsigned long *received_map; /* Pages that we have received */
+ unsigned long *requested_map; /* Pages that we're sending a request for */
+};
+
/* State for the incoming migration */
struct MigrationIncomingState {
QEMUFile *file;
@@ -71,6 +88,7 @@ struct MigrationIncomingState {
QEMUFile *return_path;
QemuMutex rp_mutex; /* We send replies from multiple threads */
+ PostcopyPMI postcopy_pmi;
};
MigrationIncomingState *migration_incoming_get_current(void);
diff --git a/include/migration/postcopy-ram.h b/include/migration/postcopy-ram.h
index fe89a3c..04c2ec8 100644
--- a/include/migration/postcopy-ram.h
+++ b/include/migration/postcopy-ram.h
@@ -36,4 +36,14 @@ int postcopy_ram_discard_range(MigrationIncomingState *mis,
uint8_t *start,
int postcopy_send_discard_bm_ram(MigrationState *ms, const char *name,
unsigned long start, unsigned long end);
+/*
+ * In 'advise' mode record that a page has been received.
+ */
+void postcopy_hook_early_receive(MigrationIncomingState *mis,
+ size_t bitmap_index);
+
+void postcopy_pmi_destroy(MigrationIncomingState *mis);
+void postcopy_pmi_discard_range(MigrationIncomingState *mis,
+ size_t start, size_t npages);
+void postcopy_pmi_dump(MigrationIncomingState *mis);
#endif
diff --git a/include/qemu/typedefs.h b/include/qemu/typedefs.h
index 8539de6..61b330c 100644
--- a/include/qemu/typedefs.h
+++ b/include/qemu/typedefs.h
@@ -77,6 +77,7 @@ typedef struct QEMUSGList QEMUSGList;
typedef struct SHPCDevice SHPCDevice;
typedef struct FWCfgState FWCfgState;
typedef struct PcGuestInfo PcGuestInfo;
+typedef struct PostcopyPMI PostcopyPMI;
typedef struct Range Range;
typedef struct AdapterInfo AdapterInfo;
diff --git a/postcopy-ram.c b/postcopy-ram.c
index ba6cf17..86ce68c 100644
--- a/postcopy-ram.c
+++ b/postcopy-ram.c
@@ -23,6 +23,8 @@
#include "qemu-common.h"
#include "migration/migration.h"
#include "migration/postcopy-ram.h"
+#include "qemu/bitmap.h"
+#include "qemu/error-report.h"
#include "sysemu/sysemu.h"
//#define DEBUG_POSTCOPY
@@ -74,6 +76,140 @@
#define USERFAULTFD_PROTOCOL (uint64_t)0xaa
#endif
+/* ---------------------------------------------------------------------- */
+/* Postcopy pagemap-inbound (pmi) - data structures that record the */
+/* state of each page used by the inbound postcopy */
+
+static void postcopy_pmi_init(MigrationIncomingState *mis, size_t ram_pages)
+{
+ qemu_mutex_init(&mis->postcopy_pmi.mutex);
+ mis->postcopy_pmi.received_map = bitmap_new(ram_pages);
+ mis->postcopy_pmi.requested_map = bitmap_new(ram_pages);
+ bitmap_clear(mis->postcopy_pmi.received_map, 0, ram_pages);
+ bitmap_clear(mis->postcopy_pmi.requested_map, 0, ram_pages);
+}
+
+void postcopy_pmi_destroy(MigrationIncomingState *mis)
+{
+ if (mis->postcopy_pmi.received_map) {
+ g_free(mis->postcopy_pmi.received_map);
+ mis->postcopy_pmi.received_map = NULL;
+ }
+ if (mis->postcopy_pmi.requested_map) {
+ g_free(mis->postcopy_pmi.requested_map);
+ mis->postcopy_pmi.requested_map = NULL;
+ }
+ qemu_mutex_destroy(&mis->postcopy_pmi.mutex);
+}
+
+/*
+ * Mark a set of pages in the PMI as being clear; this is used by the discard
+ * at the start of postcopy, and before the postcopy stream starts.
+ */
+void postcopy_pmi_discard_range(MigrationIncomingState *mis,
+ size_t start, size_t npages)
+{
+ bitmap_clear(mis->postcopy_pmi.received_map, start, npages);
+}
+
+/*
+ * Retrieve the state of the given page
+ * Note: This version for use by callers already holding the lock
+ */
+static PostcopyPMIState postcopy_pmi_get_state_nolock(
+ MigrationIncomingState *mis,
+ size_t bitmap_index)
+{
+ bool received, requested;
+
+ received = test_bit(bitmap_index, mis->postcopy_pmi.received_map);
+ requested = test_bit(bitmap_index, mis->postcopy_pmi.requested_map);
+
+ if (received) {
+ assert(!requested);
+ return POSTCOPY_PMI_RECEIVED;
+ } else {
+ return requested ? POSTCOPY_PMI_REQUESTED : POSTCOPY_PMI_MISSING;
+ }
+}
+
+/* Retrieve the state of the given page */
+static PostcopyPMIState postcopy_pmi_get_state(MigrationIncomingState *mis,
+ size_t bitmap_index)
+{
+ PostcopyPMIState ret;
+ qemu_mutex_lock(&mis->postcopy_pmi.mutex);
+ ret = postcopy_pmi_get_state_nolock(mis, bitmap_index);
+ qemu_mutex_unlock(&mis->postcopy_pmi.mutex);
+
+ return ret;
+}
+
+/*
+ * Set the page state to the given state if the previous state was as expected
+ * Return the actual previous state.
+ */
+static PostcopyPMIState postcopy_pmi_change_state(MigrationIncomingState *mis,
+ size_t bitmap_index,
+ PostcopyPMIState expected_state,
+ PostcopyPMIState new_state)
+{
+ PostcopyPMIState old_state;
+
+ qemu_mutex_lock(&mis->postcopy_pmi.mutex);
+ old_state = postcopy_pmi_get_state_nolock(mis, bitmap_index);
+
+ if (old_state == expected_state) {
+ switch (new_state) {
+ case POSTCOPY_PMI_MISSING:
+ assert(0); /* This shouldn't actually happen - use discard_range */
+ break;
+
+ case POSTCOPY_PMI_REQUESTED:
+ assert(old_state == POSTCOPY_PMI_MISSING);
+ set_bit(bitmap_index, mis->postcopy_pmi.requested_map);
+ break;
+
+ case POSTCOPY_PMI_RECEIVED:
+ assert(old_state == POSTCOPY_PMI_MISSING ||
+ old_state == POSTCOPY_PMI_REQUESTED);
+ set_bit(bitmap_index, mis->postcopy_pmi.received_map);
+ clear_bit(bitmap_index, mis->postcopy_pmi.requested_map);
+ break;
+ }
+ }
+
+ qemu_mutex_unlock(&mis->postcopy_pmi.mutex);
+ return old_state;
+}
+
+/*
+ * Useful when debugging postcopy, although if it failed early the
+ * received map can be quite sparse and thus big when dumped.
+ */
+void postcopy_pmi_dump(MigrationIncomingState *mis)
+{
+ fprintf(stderr, "postcopy_pmi_dump: requested\n");
+ ram_debug_dump_bitmap(mis->postcopy_pmi.requested_map, false);
+ fprintf(stderr, "postcopy_pmi_dump: received\n");
+ ram_debug_dump_bitmap(mis->postcopy_pmi.received_map, true);
+ fprintf(stderr, "postcopy_pmi_dump: end\n");
+}
+
+/* Called by ram_load prior to mapping the page */
+void postcopy_hook_early_receive(MigrationIncomingState *mis,
+ size_t bitmap_index)
+{
+ if (mis->postcopy_ram_state == POSTCOPY_RAM_INCOMING_ADVISE) {
+ /*
+ * If we're in precopy-advise mode we need to track received pages even
+ * though we don't need to place pages atomically yet.
+ * In advise mode there's only a single thread, so don't need locks
+ */
+ set_bit(bitmap_index, mis->postcopy_pmi.received_map);
+ }
+}
+
int postcopy_ram_hosttest(void)
{
/* TODO: Needs guarding with CONFIG_ once we have libc's that have the defs
@@ -169,6 +305,14 @@ int postcopy_ram_discard_range(MigrationIncomingState
*mis, void *start,
error_report("postcopy_ram_discard_range: No OS support");
return -1;
}
+
+/* Called by ram_load prior to mapping the page */
+void postcopy_hook_early_receive(MigrationIncomingState *mis,
+ size_t bitmap_index)
+{
+ /* We don't support postcopy so don't care */
+}
+
#endif
/* ------------------------------------------------------------------------- */
--
1.9.3
- [Qemu-devel] [PATCH v3 06/47] Add qemu_get_counted_string to read a string prefixed by a count byte, (continued)
- [Qemu-devel] [PATCH v3 06/47] Add qemu_get_counted_string to read a string prefixed by a count byte, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 18/47] Add migration-capability boolean for postcopy-ram., Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 20/47] QEMU_VM_CMD_PACKAGED: Send a packaged chunk of migration stream, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 22/47] Allow savevm handlers to state whether they could go into postcopy, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 23/47] postcopy: OS support test, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 11/47] Migration commands, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 21/47] migrate_init: Call from savevm, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 24/47] migrate_start_postcopy: Command to trigger transition to postcopy, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 25/47] MIG_STATE_POSTCOPY_ACTIVE: Add new migration state, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 27/47] Postcopy: Maintain sentmap during postcopy pre phase, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 28/47] Postcopy page-map-incoming (PMI) structure,
Dr. David Alan Gilbert (git) <=
- [Qemu-devel] [PATCH v3 29/47] postcopy: Add incoming_init/cleanup functions, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 26/47] qemu_savevm_state_complete: Postcopy changes, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 15/47] qemu_loadvm errors and debug, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 19/47] Add wrappers and handlers for sending/receiving the postcopy-ram migration messages., Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 31/47] postcopy: ram_enable_notify to switch on userfault, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 34/47] mig fd_connect: open return path, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 33/47] Postcopy: Rework migration thread for postcopy mode, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 32/47] Postcopy: postcopy_start, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 36/47] Page request: Add MIG_RPCOMM_REQPAGES reverse command, Dr. David Alan Gilbert (git), 2014/08/28
- [Qemu-devel] [PATCH v3 37/47] Page request: Process incoming page request, Dr. David Alan Gilbert (git), 2014/08/28