Postcopy: Hugepage support
v3 cover Postcopy: Hugepage support
From: "Dr. David Alan Gilbert" <[email protected]>
Hi,
The existing postcopy code, and the userfault kernel
code that supports it, only works for normal anonymous memory. Kernel support for userfault on hugetlbfs has just been merged in Linus's tree for 4.11 (see 4c9a7831b11 merge)
Note that while this code supports arbitrary sized hugepages, it doesn't make sense with pages above the few-MB region, so while 2MB is fine, 1GB is probably a bad idea; this code waits for and transmits whole huge pages, and a 1GB page would take about 1 second to transfer over a 10Gbps link - which is way too long to pause the destination for.
Note: 'postcopy: Update userfaultfd.h header' is now from Paolo's recent header update run; it can be dropped as soon as Paolo's goes in.
Dave
v3
Added an extra check in 'postcopy: Add extra check for COPY function' Updates from Laurent's review:
moved the CONFIG_FALLOCATE_PUNCH_HOLE from 'ram_block_discard_range' into the following 'enhance ram_block_discard_range for hugepages' Merged the ram_block_discard_range / Fold postcopy_ram_discard_range into ram_discard_range patches
Removed the excess rcu_read_lock in ram_block_discard_range Removed a removal of a blank line in 'Mask fault address'
Updated the 'Update userfaultfd.h header' - that's now from Paolo's update
Dr. David Alan Gilbert (16):
postcopy: Transmit ram size summary word
postcopy: Transmit and compare individual page sizes
postcopy: Chunk discards for hugepages
exec: ram_block_discard_range
postcopy: enhance ram_block_discard_range for hugepages
postcopy: Record largest page size
postcopy: Plumb pagesize down into place helpers
postcopy: Use temporary for placing zero huge pages
postcopy: Load huge pages in one go
postcopy: Mask fault addresses to huge page boundary
postcopy: Send whole huge pages
postcopy: Allow hugepages
postcopy: Update userfaultfd.h header
postcopy: Check for userfault+hugepage feature
postcopy: Add doc about hugepages and postcopy
postcopy: Add extra check for COPY function
docs/migration.txt | 13 ++++ exec.c | 83 ++++++++++++++++++++++ include/exec/cpu-common.h | 2 + include/migration/migration.h | 3 + include/migration/postcopy-ram.h | 13 ++-- linux-headers/linux/userfaultfd.h | 67 +++++++++++++++--- migration/migration.c | 1 + migration/postcopy-ram.c | 142 ++++++++++++++++++-------------------- migration/ram.c | 109 ++++++++++++++++++----------- migration/savevm.c | 32 ++++++--- migration/trace-events | 2 +- 11 files changed, 319 insertions(+), 148 deletions(-)
Signature · 1 line
2.9.3
PATCH v3 1/16 postcopy: Transmit ram size summary word
From: "Dr. David Alan Gilbert" <[email protected]>
Replace the host page-size in the 'advise' command by a pagesize summary bitmap; if the VM is just using normal RAM then this will be exactly the same as before, however if they're using huge pages they'll be different, and thus:
a) Migration from/to old qemu's that don't understand huge pages will fail early.
b) Migrations with different size RAMBlocks will also fail early.
This catches it very early; earlier than the detailed per-block check in the next patch.
--- include/migration/migration.h | 1 + migration/ram.c | 17 +++++++++++++++++ migration/savevm.c | 32 +++++++++++++++++++++----------- 3 files changed, 39 insertions(+), 11 deletions(-)
include/migration/migration.h +1 -0
@@ -375,6 +375,7 @@ void global_state_store_running(void);void flush_page_queue (MigrationState *ms);int ram_save_queue_pages (MigrationState *ms,const char *rbname,ram_addr_t start,ram_addr_t len); +uint64_t ram_pagesize_summary (void );PostcopyState postcopy_state_get (void );/* Set the state and return the old state */
migration/ram.c +17 -0
@@ -600,6 +600,23 @@ static void migration_bitmap_sync_init(void) iterations_prev =0 ; } +/* Returns a summary bitmap of the page sizes of all RAMBlocks; +* for VMs with just normal pages this is equivalent to the +* host page size. If it's got some huge pages then it's the OR +* of all the different page sizes. +*/ +uint64_t ram_pagesize_summary (void ) +{ +RAMBlock *block; +uint64_t summary =0 ; + + QLIST_FOREACH_RCU(block, &ram_list.blocks, next) { + summary |= block->page_size; + } + +return summary; +} +static void migration_bitmap_sync (void ) {RAMBlock *block;
migration/savevm.c +21 -11
@@ -869,7 +869,7 @@ int qemu_savevm_send_packaged(QEMUFile *f, const uint8_t *buf, size_t len)void qemu_savevm_send_postcopy_advise (QEMUFile *f) {uint64_t tmp[2 ]; - tmp[0 ] =cpu_to_be64 (getpagesize ()); + tmp[0 ] =cpu_to_be64 (ram_pagesize_summary ()); tmp[1 ] =cpu_to_be64 (1ul <<qemu_target_page_bits ());trace_qemu_savevm_send_postcopy_advise ();
@@ -1346,7 +1346,7 @@ static int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis);static int loadvm_postcopy_handle_advise (MigrationIncomingState *mis) {PostcopyState ps =postcopy_state_set (POSTCOPY_INCOMING_ADVISE ); -uint64_t remote_hps, remote_tps; +uint64_t remote_pagesize_summary, local_pagesize_summary, remote_tps;trace_loadvm_postcopy_handle_advise ();if (ps !=POSTCOPY_INCOMING_NONE ) {
@@ -1359,17 +1359,27 @@ static int loadvm_postcopy_handle_advise(MigrationIncomingState *mis)return -1 ; } - remote_hps =qemu_get_be64 (mis->from_src_file); -if (remote_hps !=getpagesize ()) { + remote_pagesize_summary =qemu_get_be64 (mis->from_src_file); + local_pagesize_summary =ram_pagesize_summary (); + +if (remote_pagesize_summary != local_pagesize_summary) {/* -* Some combinations of mismatch are probably possible but it gets -* a bit more complicated. In particular we need to place whole -* host pages on the dest at once, and we need to ensure that we -* handle dirtying to make sure we never end up sending part of -* a hostpage on it's own. +* This detects two potential causes of mismatch: +* a) A mismatch in host page sizes +* Some combinations of mismatch are probably possible but it gets +* a bit more complicated. In particular we need to place whole +* host pages on the dest at once, and we need to ensure that we +* handle dirtying to make sure we never end up sending part of +* a hostpage on it's own. +* b) The use of different huge page sizes on source/destination +* a more fine grain test is performed during RAM block migration +* but this test here causes a nice early clear failure, and +* also fails when passed to an older qemu that doesn't +* do huge pages. */ -error_report ("Postcopy needs matching host page sizes (s=%d d=%d)" , - (int )remote_hps,getpagesize ()); +error_report ("Postcopy needs matching RAM page sizes (s=%" PRIx64 +" d=%" PRIx64")" , + remote_pagesize_summary, local_pagesize_summary);return -1 ; }
Signature · 1 line
2.9.3
PATCH v3 2/16 postcopy: Transmit and compare individual page sizes
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
When using postcopy with hugepages, we require the source and destination page sizes for any RAMBlock to match; note that different RAMBlocks in the same VM can have different page sizes.
Transmit them as part of the RAM information header and fail if there's a difference.
--- migration/ram.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
migration/ram.c +17 -0
@@ -2027,6 +2027,9 @@ static int ram_save_setup(QEMUFile *f, void *opaque)qemu_put_byte (f,strlen (block->idstr));qemu_put_buffer (f, (uint8_t *)block->idstr,strlen (block->idstr));qemu_put_be64 (f, block->used_length); +if (migrate_postcopy_ram () && block->page_size != qemu_host_page_size) { +qemu_put_be64 (f, block->page_size); + } }rcu_read_unlock ();
@@ -2528,6 +2531,8 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)* be atomic */ bool postcopy_running =postcopy_state_get () >=POSTCOPY_INCOMING_LISTENING ; +/* ADVISE is earlier, it shows the source has the postcopy capability on */ +bool postcopy_advised =postcopy_state_get () >=POSTCOPY_INCOMING_ADVISE ; seq_iter++;
@@ -2592,6 +2597,18 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id)error_report_err (local_err); } } +/* For postcopy we need to check hugepage sizes match */ +if (postcopy_advised && + block->page_size != qemu_host_page_size) { +uint64_t remote_page_size =qemu_get_be64 (f); +if (remote_page_size != block->page_size) { +error_report ("Mismatched RAM page size %s " +"(local) %zd != %" PRId64, + id, block->page_size, + remote_page_size); + ret = -EINVAL ; + } + }ram_control_load_hook (f,RAM_CONTROL_BLOCK_REG , block->idstr); }else {
Signature · 1 line
2.9.3
PATCH v3 3/16 postcopy: Chunk discards for hugepages
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
At the start of the postcopy phase, partially sent huge pages must be discarded. The code for dealing with host page sizes larger than the target page size can be reused for this case.
--- migration/ram.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
migration/ram.c +9 -8
@@ -1672,12 +1672,17 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass, {unsigned long *bitmap;unsigned long *unsentmap; -unsigned int host_ratio = qemu_host_page_size /TARGET_PAGE_SIZE ; +unsigned int host_ratio = block->page_size /TARGET_PAGE_SIZE ;unsigned long first = block->offset >>TARGET_PAGE_BITS ;unsigned long len = block->used_length >>TARGET_PAGE_BITS ;unsigned long last = first + (len -1 );unsigned long run_start; +if (block->page_size ==TARGET_PAGE_SIZE ) { +/* Easy case - TPS==HPS for a non-huge page RAMBlock */ +return ; + } + bitmap =atomic_rcu_read (&migration_bitmap_rcu)->bmap; unsentmap =atomic_rcu_read (&migration_bitmap_rcu)->unsentmap;
@@ -1781,7 +1786,8 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,* Utility for the outgoing postcopy code. * * Discard any partially sent host-page size chunks, mark any partially -* dirty host-page size chunks as all dirty. +* dirty host-page size chunks as all dirty. In this case the host-page +* is the host-page for the particular RAMBlock, i.e. it might be a huge page * * Returns: 0 on success */
@@ -1789,11 +1795,6 @@ static int postcopy_chunk_hostpages(MigrationState *ms) {struct RAMBlock *block; -if (qemu_host_page_size ==TARGET_PAGE_SIZE ) { -/* Easy case - TPS==HPS - nothing to be done */ -return 0 ; - } -/* Easiest way to make sure we don't resume in the middle of a host-page */ last_seen_block =NULL ; last_sent_block =NULL ;
@@ -1849,7 +1850,7 @@ int ram_postcopy_send_discard_bitmap(MigrationState *ms)return -EINVAL ; } -/* Deal with TPS != HPS */ +/* Deal with TPS != HPS and huge pages */ ret =postcopy_chunk_hostpages (ms);if (ret) {rcu_read_unlock ();
Signature · 1 line
2.9.3
PATCH v3 4/16 exec: ram_block_discard_range
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Create ram_block_discard_range in exec.c to replace postcopy_ram_discard_range and most of ram_discard_range.
Those two routines are a bit of a weird combination, and ram_discard_range is about to get more complex for hugepages. It's OS dependent code (so shouldn't be in migration/ram.c) but it needs quite a bit of the innards of RAMBlock so doesn't belong in the os*.c.
--- exec.c | 54 ++++++++++++++++++++++++++++++++++++++++ include/exec/cpu-common.h | 1 + include/migration/postcopy-ram.h | 7 ------ migration/postcopy-ram.c | 30 +--------------------- migration/ram.c | 24 +++--------------- migration/trace-events | 2 +- 6 files changed, 60 insertions(+), 58 deletions(-)
exec.c +54 -0
@@ -45,6 +45,7 @@#include "exec/address-spaces.h" #include "sysemu/xen-mapcache.h" #include "trace-root.h" +#endif #include "exec/cpu-all.h" #include "qemu/rcu_queue.h"
@@ -3288,4 +3289,57 @@ int qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque)rcu_read_unlock (); return ret; } + +/* +* Unmap pages of memory from start to start+length such that +* they a) read as 0, b) Trigger whatever fault mechanism +* the OS provides for postcopy. +* The pages must be unmapped by the end of the function. +* Returns: 0 on success, none-0 on failure +* +*/ +int ram_block_discard_range (RAMBlock *rb,uint64_t start,size_t length) +{ +int ret =-1 ; + +uint8_t *host_startaddr = rb->host + start; + +if ((uintptr_t )host_startaddr & (rb->page_size -1 )) { +error_report ("ram_block_discard_range: Unaligned start address: %p" , + host_startaddr); + goto err; + } + +if ((start + length) <= rb->used_length) { +uint8_t *host_endaddr = host_startaddr + length; +if ((uintptr_t )host_endaddr & (rb->page_size -1 )) { +error_report ("ram_block_discard_range: Unaligned end address: %p" , + host_endaddr); + goto err; + } + + errno =ENOTSUP ;/* If we are missing MADVISE etc */ + +#if defined(CONFIG_MADVISE ) +/* Note: We need the madvise MADV_DONTNEED behaviour of definitely +* freeing the page. +*/ + ret =madvise (host_startaddr, length,MADV_DONTNEED ); +#endif +if (ret) { + ret = -errno; +error_report ("ram_block_discard_range: Failed to discard range " +"%s:%" PRIx64" +%zx (%d)" , + rb->idstr, start, length, ret); + } + }else { +error_report ("ram_block_discard_range: Overrun block '%s' (%" PRIu64 +"/%zx/" RAM_ADDR_FMT ")" , + rb->idstr, start, length, rb->used_length); + } + +err: +return ret; +} +#endif
include/exec/cpu-common.h +1 -0
@@ -105,6 +105,7 @@ typedef int (RAMBlockIterFunc)(const char *block_name, void *host_addr, ram_addr_t offset, ram_addr_t length, void *opaque);int qemu_ram_foreach_block (RAMBlockIterFunc func,void *opaque); +int ram_block_discard_range (RAMBlock *rb,uint64_t start,size_t length);#endif
include/migration/postcopy-ram.h +0 -7
@@ -35,13 +35,6 @@ int postcopy_ram_incoming_init(MigrationIncomingState *mis, size_t ram_pages);int postcopy_ram_incoming_cleanup (MigrationIncomingState *mis);/* -* Discard the contents of 'length' bytes from 'start' -* We can assume that if we've been called postcopy_ram_hosttest returned true -*/ -int postcopy_ram_discard_range (MigrationIncomingState *mis,uint8_t *start, -size_t length); - -/* * Userfault requires us to mark RAM as NOHUGEPAGE prior to discard * however leaving it until after precopy means that most of the precopy * data is still THPd
migration/postcopy-ram.c +1 -29
@@ -200,27 +200,6 @@ out:return ret; } -/** -* postcopy_ram_discard_range: Discard a range of memory. -* We can assume that if we've been called postcopy_ram_hosttest returned true. -* -* @mis: Current incoming migration state. -* @start, @length: range of memory to discard. -* -* returns: 0 on success. -*/ -int postcopy_ram_discard_range (MigrationIncomingState *mis,uint8_t *start, -size_t length) -{ -trace_postcopy_ram_discard_range (start, length); -if (madvise (start, length,MADV_DONTNEED )) { -error_report ("%s MADV_DONTNEED: %s" , __func__,strerror (errno)); -return -1 ; - } - -return 0 ; -} -/* * Setup an area of RAM so that it *can* be used for postcopy later; this * must be done right at the start prior to pre-copy.
@@ -239,7 +218,7 @@ static int init_range(const char *block_name, void *host_addr,* - we're going to get the copy from the source anyway. * (Precopy will just overwrite this data, so doesn't need the discard) */ -if (postcopy_ram_discard_range (mis, host_addr, length)) { +if (ram_discard_range (mis, block_name,0 , length)) {return -1 ; }
@@ -658,13 +637,6 @@ int postcopy_ram_incoming_cleanup(MigrationIncomingState *mis)return -1 ; } -int postcopy_ram_discard_range (MigrationIncomingState *mis,uint8_t *start, -size_t length) -{ -assert (0 ); -return -1 ; -} -int postcopy_ram_prepare_discard (MigrationIncomingState *mis) {assert (0 );
migration/ram.c +3 -21
@@ -1890,6 +1890,8 @@ int ram_discard_range(MigrationIncomingState *mis, {int ret =-1 ; +trace_ram_discard_range (block_name, start, length); +rcu_read_lock ();RAMBlock *rb =qemu_ram_block_by_name (block_name);
@@ -1899,27 +1901,7 @@ int ram_discard_range(MigrationIncomingState *mis, goto err; } -uint8_t *host_startaddr = rb->host + start; - -if ((uintptr_t )host_startaddr & (qemu_host_page_size -1 )) { -error_report ("ram_discard_range: Unaligned start address: %p" , - host_startaddr); - goto err; - } - -if ((start + length) <= rb->used_length) { -uint8_t *host_endaddr = host_startaddr + length; -if ((uintptr_t )host_endaddr & (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, length); - }else { -error_report ("ram_discard_range: Overrun block '%s' (%" PRIu64 -"/%zx/" RAM_ADDR_FMT ")" , - block_name, start, length, rb->used_length); - } + ret =ram_block_discard_range (rb, start, length); err:rcu_read_unlock ();
migration/trace-events +1 -1
@@ -68,6 +68,7 @@ get_queued_page_not_dirty(const char *block_name, uint64_t tmp_offset, uint64_t migration_bitmap_sync_start(void) "" migration_bitmap_sync_end(uint64_t dirty_pages) "dirty_pages %" PRIu64 migration_throttle(void) "" +ram_discard_range(const char *rbname, uint64_t start, size_t len) "%s: start: %" PRIx64 " %zx" ram_load_postcopy_loop(uint64_t addr, int flags) "@%" PRIx64 " %x" ram_postcopy_send_discard_bitmap(void) "" ram_save_queue_pages(const char *rbname, size_t start, size_t len) "%s: start: %zx len: %zx"
@@ -176,7 +177,6 @@ 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_discard_send_range(const char *ramblock, unsigned long start, unsigned long length) "%s:%lx/%lx" -postcopy_ram_discard_range(void *start, size_t length) "%p,+%zx" postcopy_cleanup_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=%zx length=%zx" postcopy_init_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=%zx length=%zx" postcopy_nhp_range(const char *ramblock, void *host_addr, size_t offset, size_t length) "%s: %p offset=%zx length=%zx"
Signature · 1 line
2.9.3
Re: [Qemu-devel] [PATCH v3 04/16] exec: ram_block_discard_range
Quoted 27 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
Create
ram_block_discard_rangeinexec.cto replacepostcopy_ram_discard_rangeand most ofram_discard_range.Those two routines are a bit of a weird combination, and
ram_discard_rangeis about to get more complex for hugepages. It's OS dependent code (so shouldn't be inmigration/ram.c) but it needs quite a bit of the innards of RAMBlock so doesn't belong in the os*.c.Signed-off-by Dr. David Alan Gilbert <[email protected]>Reviewed-by Juan Quintela <[email protected]>--- exec.c | 54 ++++++++++++++++++++++++++++++++++++++++ include/exec/cpu-common.h | 1 + include/migration/postcopy-ram.h | 7 ------ migration/postcopy-ram.c | 30 +--------------------- migration/ram.c | 24 +++--------------- migration/trace-events | 2 +- 6 files changed, 60 insertions(+), 58 deletions(-)exec.c +0
-0
exec.c line 49
Quoted 5 lines
exec.c +1
-0@@ -45,6 +45,7 @@#include "exec/address-spaces.h" #include "sysemu/xen-mapcache.h" #include "trace-root.h" +#endif
It seems a blank line has "migrated" here from PATCH v2 11/16. ;)
PATCH v3 5/16 postcopy: enhance ram_block_discard_range for hugepages
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Unfortunately madvise DONTNEED doesn't work on hugepagetlb so use fallocate(FALLOC_FL_PUNCH_HOLE) qemu_fd_getpagesize only sets the page based off a file if the file is from hugetlbfs.
--- exec.c | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-)
exec.c +20 -4
@@ -46,6 +46,11 @@#include "sysemu/xen-mapcache.h" #include "trace-root.h" +#ifdef CONFIG_FALLOCATE_PUNCH_HOLE +#include <fcntl.h> +#include <linux/falloc.h> +#endif +#endif #include "exec/cpu-all.h" #include "qemu/rcu_queue.h"
@@ -3320,12 +3325,23 @@ int ram_block_discard_range(RAMBlock *rb, uint64_t start, size_t length) errno =ENOTSUP ;/* If we are missing MADVISE etc */ +if (rb->page_size == qemu_host_page_size) {#if defined(CONFIG_MADVISE ) -/* Note: We need the madvise MADV_DONTNEED behaviour of definitely -* freeing the page. -*/ - ret =madvise (host_startaddr, length,MADV_DONTNEED ); +/* Note: We need the madvise MADV_DONTNEED behaviour of definitely +* freeing the page. +*/ + ret =madvise (host_startaddr, length,MADV_DONTNEED );#endif + }else { +/* Huge page case - unfortunately it can't do DONTNEED, but +* it can do the equivalent by FALLOC_FL_PUNCH_HOLE in the +* huge page file. +*/ +#ifdef CONFIG_FALLOCATE_PUNCH_HOLE + ret =fallocate (rb->fd,FALLOC_FL_PUNCH_HOLE |FALLOC_FL_KEEP_SIZE , + start, length); +#endif + }if (ret) { ret = -errno; error_report("ram_block_discard_range: Failed to discard range "
Signature · 1 line
2.9.3
PATCH v3 6/16 postcopy: Record largest page size
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Record the largest page size in use; we'll need it soon for allocating temporary buffers.
--- exec.c | 13 +++++++++++++ include/exec/cpu-common.h | 1 + include/migration/migration.h | 1 + migration/migration.c | 1 + 4 files changed, 16 insertions(+)
exec.c +13 -0
@@ -1524,6 +1524,19 @@ size_t qemu_ram_pagesize(RAMBlock *rb)return rb->page_size; } +/* Returns the largest size of page in use */ +size_t qemu_ram_pagesize_largest (void ) +{ +RAMBlock *block; +size_t largest =0 ; + + QLIST_FOREACH_RCU(block, &ram_list.blocks, next) { + largest =MAX (largest,qemu_ram_pagesize (block)); + } + +return largest; +} +static int memory_try_enable_merging (void *addr,size_t len) {if (!machine_mem_merge (current_machine)) {
include/exec/cpu-common.h +1 -0
@@ -64,6 +64,7 @@ void qemu_ram_set_idstr(RAMBlock *block, const char *name, DeviceState *dev);void qemu_ram_unset_idstr (RAMBlock *block);const char *qemu_ram_get_idstr (RAMBlock *rb);size_t qemu_ram_pagesize (RAMBlock *block); +size_t qemu_ram_pagesize_largest (void );void cpu_physical_memory_rw (hwaddr addr,uint8_t *buf,int len,int is_write);
include/migration/migration.h +1 -0
@@ -92,6 +92,7 @@ struct MigrationIncomingState {*/ QemuEvent main_thread_load_event; +size_t largest_page_size;bool have_fault_thread;QemuThread fault_thread;QemuSemaphore fault_thread_sem;
migration/migration.c +1 -0
@@ -383,6 +383,7 @@ static void process_incoming_migration_co(void *opaque)int ret; mis->from_src_file = f; + mis->largest_page_size =qemu_ram_pagesize_largest ();postcopy_state_set (POSTCOPY_INCOMING_NONE );migrate_set_state (&mis->state,MIGRATION_STATUS_NONE ,MIGRATION_STATUS_ACTIVE );
Signature · 1 line
2.9.3
PATCH v3 7/16 postcopy: Plumb pagesize down into place helpers
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Now we deal with normal size pages and huge pages we need to tell the place handlers the size we're dealing with and make sure the temporary page is large enough.
--- include/migration/postcopy-ram.h | 6 +++-- migration/postcopy-ram.c | 47 ++++++++++++++++++++++++---------------- migration/ram.c | 15 +++++++------ 3 files changed, 40 insertions(+), 28 deletions(-)
include/migration/postcopy-ram.h +4 -2
@@ -74,13 +74,15 @@ void postcopy_discard_send_finish(MigrationState *ms,* to use other postcopy_ routines to allocate. * returns 0 on success */ -int postcopy_place_page (MigrationIncomingState *mis,void *host,void *from); +int postcopy_place_page (MigrationIncomingState *mis,void *host,void *from, +size_t pagesize);/* * Place a zero page at (host) atomically * returns 0 on success */ -int postcopy_place_page_zero (MigrationIncomingState *mis,void *host); +int postcopy_place_page_zero (MigrationIncomingState *mis,void *host, +size_t pagesize);/* * Allocate a page of memory that can be mapped at a later point in time
migration/postcopy-ram.c +28 -19
99 lines not on this page · raw message
migration/ram.c +8 -7
@@ -2402,6 +2402,7 @@ static int ram_load_postcopy(QEMUFile *f)void *host =NULL ;void *page_buffer =NULL ;void *place_source =NULL ; +RAMBlock *block =NULL ;uint8_t ch; addr =qemu_get_be64 (f);
@@ -2411,7 +2412,7 @@ static int ram_load_postcopy(QEMUFile *f)trace_ram_load_postcopy_loop ((uint64_t )addr, flags); place_needed = false;if (flags & (RAM_SAVE_FLAG_COMPRESS |RAM_SAVE_FLAG_PAGE )) { -RAMBlock *block =ram_block_from_stream (f, flags); + block =ram_block_from_stream (f, flags); host =host_from_ram_block_offset (block, addr);if (!host) {
@@ -2486,14 +2487,14 @@ static int ram_load_postcopy(QEMUFile *f)if (place_needed) {/* This gets called at the last target page in the host page */ +void *place_dest = host +TARGET_PAGE_SIZE - block->page_size; +if (all_zero) { - ret =postcopy_place_page_zero (mis, - host +TARGET_PAGE_SIZE - - qemu_host_page_size); + ret =postcopy_place_page_zero (mis, place_dest, + block->page_size); }else { - ret =postcopy_place_page (mis, host +TARGET_PAGE_SIZE - - qemu_host_page_size, - place_source); + ret =postcopy_place_page (mis, place_dest, + place_source, block->page_size); } }if (!ret) {
Signature · 1 line
2.9.3
PATCH v3 8/16 postcopy: Use temporary for placing zero huge pages
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
The kernel can't do UFFDIO_ZEROPAGE for huge pages, so we have to allocate a temporary (always zero) page and use UFFDIO_COPYPAGE on it.
--- include/migration/migration.h | 1 + migration/postcopy-ram.c | 23 +++++++++++++++++++++-- 2 files changed, 22 insertions(+), 2 deletions(-)
include/migration/migration.h +1 -0
@@ -108,6 +108,7 @@ struct MigrationIncomingState {QEMUFile *to_src_file;QemuMutex rp_mutex;/* We send replies from multiple threads */ void *postcopy_tmp_page; +void *postcopy_tmp_zero_page;QEMUBH *bh;
migration/postcopy-ram.c +21 -2
@@ -324,6 +324,10 @@ int postcopy_ram_incoming_cleanup(MigrationIncomingState *mis)munmap (mis->postcopy_tmp_page, mis->largest_page_size); mis->postcopy_tmp_page =NULL ; } +if (mis->postcopy_tmp_zero_page) { +munmap (mis->postcopy_tmp_zero_page, mis->largest_page_size); + mis->postcopy_tmp_zero_page =NULL ; + }trace_postcopy_ram_incoming_cleanup_exit ();return 0 ; }
@@ -593,8 +597,23 @@ int postcopy_place_page_zero(MigrationIncomingState *mis, void *host,return -e; } }else { -/* TODO: The kernel can't use UFFDIO_ZEROPAGE for hugepages */ -assert (0 ); +/* The kernel can't use UFFDIO_ZEROPAGE for hugepages */ +if (!mis->postcopy_tmp_zero_page) { + mis->postcopy_tmp_zero_page =mmap (NULL , mis->largest_page_size, +PROT_READ |PROT_WRITE , +MAP_PRIVATE |MAP_ANONYMOUS , +-1 ,0 ); +if (mis->postcopy_tmp_zero_page ==MAP_FAILED ) { +int e = errno; + mis->postcopy_tmp_zero_page =NULL ; +error_report ("%s: %s mapping large zero page" , + __func__,strerror (e)); +return -e; + } +memset (mis->postcopy_tmp_zero_page,'\0' , mis->largest_page_size); + } +return postcopy_place_page (mis, host, mis->postcopy_tmp_zero_page, + pagesize); }return 0 ;
Signature · 1 line
2.9.3
PATCH v3 9/16 postcopy: Load huge pages in one go
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
The existing postcopy RAM load loop already ensures that it glues together whole host-pages from the target page size chunks sent over the wire. Modify the definition of host page that it uses to be the RAM block page size and thus be huge pages where appropriate.
--- migration/ram.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
migration/ram.c +8 -5
@@ -2390,7 +2390,7 @@ static int ram_load_postcopy(QEMUFile *f) {int flags =0 , ret =0 ;bool place_needed = false; -bool matching_page_sizes = qemu_host_page_size ==TARGET_PAGE_SIZE ; +bool matching_page_sizes = false;MigrationIncomingState *mis =migration_incoming_get_current ();/* Temporary page that is later 'placed' */ void *postcopy_host_page =postcopy_get_tmp_page (mis);
@@ -2420,8 +2420,11 @@ static int ram_load_postcopy(QEMUFile *f) ret = -EINVAL ;break ; } + matching_page_sizes = block->page_size ==TARGET_PAGE_SIZE ;/* -* Postcopy requires that we place whole host pages atomically. +* Postcopy requires that we place whole host pages atomically; +* these may be huge pages for RAMBlocks that are backed by +* hugetlbfs. * To make it atomic, the data is read into a temporary page * that's moved into place later. * The migration protocol uses, possibly smaller, target-pages
@@ -2429,9 +2432,9 @@ static int ram_load_postcopy(QEMUFile *f)* of a host page in order. */ page_buffer = postcopy_host_page + - ((uintptr_t )host & ~qemu_host_page_mask); + ((uintptr_t )host & (block->page_size -1 ));/* If all TP are zero then we can optimise the place */ -if (!((uintptr_t )host & ~qemu_host_page_mask)) { +if (!((uintptr_t )host & (block->page_size -1 ))) { all_zero = true; }else {/* not the 1st TP within the HP */
@@ -2449,7 +2452,7 @@ static int ram_load_postcopy(QEMUFile *f)* page */ place_needed = (((uintptr_t )host +TARGET_PAGE_SIZE ) & - ~qemu_host_page_mask) ==0 ; + (block->page_size -1 )) ==0 ; place_source = postcopy_host_page; } last_host = host;
Signature · 1 line
2.9.3
PATCH v3 10/16 postcopy: Mask fault addresses to huge page boundary
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Currently the fault address received by userfault is rounded to the host page boundary and a host page is requested from the source. Use the current RAMBlock page size instead of the general host page size so that for RAMBlocks backed by huge pages we request the whole huge page.
--- migration/postcopy-ram.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
migration/postcopy-ram.c +3 -4
@@ -403,7 +403,6 @@ static void *postcopy_ram_fault_thread(void *opaque)MigrationIncomingState *mis = opaque;struct uffd_msg msg;int ret; -size_t hostpagesize =getpagesize ();RAMBlock *rb =NULL ;RAMBlock *last_rb =NULL ;/* last RAMBlock we sent part of */
@@ -470,7 +469,7 @@ static void *postcopy_ram_fault_thread(void *opaque)break ; } - rb_offset &= ~(hostpagesize -1 ); + rb_offset &= ~(qemu_ram_pagesize (rb) -1 );trace_postcopy_ram_fault_thread_request (msg.arg.pagefault.address,qemu_ram_get_idstr (rb), rb_offset);
@@ -482,11 +481,11 @@ static void *postcopy_ram_fault_thread(void *opaque)if (rb != last_rb) { last_rb = rb;migrate_send_rp_req_pages (mis,qemu_ram_get_idstr (rb), - rb_offset, hostpagesize); + rb_offset,qemu_ram_pagesize (rb)); }else {/* Save some space */ migrate_send_rp_req_pages (mis,NULL , - rb_offset, hostpagesize); + rb_offset,qemu_ram_pagesize (rb)); } }trace_postcopy_ram_fault_thread_exit ();
Signature · 1 line
2.9.3
PATCH v3 11/16 postcopy: Send whole huge pages
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
The RAM save code uses ram_save_host_page to send whole
host pages at a time; change this to use the host page size associated with the RAM Block which may be a huge page.
--- migration/ram.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
migration/ram.c +5 -1
@@ -1302,6 +1302,8 @@ static int ram_save_target_page(MigrationState *ms, QEMUFile *f,* offset to point into the middle of a host page * in which case the remainder of the hostpage is sent. * Only dirty target pages are sent. +* Note that the host page size may be a huge page for this +* block. * * Returns: Number of pages written. *
@@ -1320,6 +1322,8 @@ static int ram_save_host_page(MigrationState *ms, QEMUFile *f, ram_addr_t dirty_ram_abs) {int tmppages, pages =0 ; +size_t pagesize =qemu_ram_pagesize (pss->block); + do { tmppages = ram_save_target_page(ms, f, pss, last_stage, bytes_transferred, dirty_ram_abs);
@@ -1330,7 +1334,7 @@ static int ram_save_host_page(MigrationState *ms, QEMUFile *f, pages += tmppages; pss->offset +=TARGET_PAGE_SIZE ; dirty_ram_abs +=TARGET_PAGE_SIZE ; - }while (pss->offset & (qemu_host_page_size -1 )); + }while (pss->offset & (pagesize -1 ));/* The offset we leave with is the last one we looked at */ pss->offset -=TARGET_PAGE_SIZE ;
Signature · 1 line
2.9.3
PATCH v3 12/16 postcopy: Allow hugepages
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Allow huge pages in postcopy.
--- migration/postcopy-ram.c | 25 +------------------------ 1 file changed, 1 insertion(+), 24 deletions(-)
migration/postcopy-ram.c +1 -24
@@ -85,24 +85,6 @@ static bool ufd_version_check(int ufd) }/* -* Check for things that postcopy won't support; returns 0 if the block -* is fine. -*/ -static int check_range (const char *block_name,void *host_addr, -ram_addr_t offset,ram_addr_t length,void *opaque) -{ -RAMBlock *rb =qemu_ram_block_by_name (block_name); - -if (qemu_ram_pagesize (rb) >getpagesize ()) { -error_report ("Postcopy doesn't support large page sizes yet (%s)" , - block_name); -return -E2BIG ; - } - -return 0 ; -} - -/* * Note: This has the side effect of munlock'ing all of RAM, that's * normally fine since if the postcopy succeeds it gets turned back on at the * end.
@@ -122,12 +104,6 @@ bool postcopy_ram_supported_by_host(void) goto out; } -/* Check for anything about the RAMBlocks we don't support */ -if (qemu_ram_foreach_block (check_range,NULL )) { -/* check_range will have printed its own error */ - goto out; - } - ufd =syscall (__NR_userfaultfd,O_CLOEXEC );if (ufd ==-1 ) { error_report("%s: userfaultfd not available: %s", __func__,
@@ -139,6 +115,7 @@ bool postcopy_ram_supported_by_host(void)if (!ufd_version_check (ufd)) { goto out; } +/* TODO: Only allow huge pages if the kernel supports it */ /* * userfault and mlock don't go together; we'll put it back later if
Signature · 1 line
2.9.3
PATCH v3 13/16 postcopy: Update userfaultfd.h header
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Just the userfaultfd.h update from Paolo's header
update run;
* Drop this patch after Paolo's update goes in *
--- linux-headers/linux/userfaultfd.h | 67 +++++++++++++++++++++++++++++++++------ 1 file changed, 58 insertions(+), 9 deletions(-)
linux-headers/linux/userfaultfd.h +58 -9
@@ -11,13 +11,18 @@#include <linux/types.h> -#define UFFD_API ((__u64)0xAA)/* -* After implementing the respective features it will become: -* #define UFFD_API_FEATURES (UFFD_FEATURE_PAGEFAULT_FLAG_WP | \ -* UFFD_FEATURE_EVENT_FORK) +* If the UFFDIO_API is upgraded someday, the UFFDIO_UNREGISTER and +* UFFDIO_WAKE ioctls should be defined as _IOW and not as _IOR. In +* userfaultfd.h we assumed the kernel was reading (instead _IOC_READ +* means the userland is reading). */ -#define UFFD_API_FEATURES (0) +#define UFFD_API ((__u64)0xAA) +#define UFFD_API_FEATURES (UFFD_FEATURE_EVENT_FORK | \ + UFFD_FEATURE_EVENT_REMAP | \ + UFFD_FEATURE_EVENT_MADVDONTNEED | \ + UFFD_FEATURE_MISSING_HUGETLBFS | \ + UFFD_FEATURE_MISSING_SHMEM)#define UFFD_API_IOCTLS \ ((__u64)1 << _UFFDIO_REGISTER | \ (__u64)1 << _UFFDIO_UNREGISTER | \
@@ -26,6 +31,9 @@ ((__u64 )1 << _UFFDIO_WAKE | \ (__u64 )1 << _UFFDIO_COPY | \ (__u64)1 << _UFFDIO_ZEROPAGE) +#define UFFD_API_RANGE_IOCTLS_BASIC \ + ((__u64)1 << _UFFDIO_WAKE | \ + (__u64)1 << _UFFDIO_COPY)/* * Valid ioctl command number range with this API is from 0x00 to
@@ -72,6 +80,21 @@ struct uffd_msg { } pagefault;struct { +__u32 ufd; + } fork; + +struct { +__u64 from; +__u64 to; +__u64 len; + } remap; + +struct { +__u64 start; +__u64 end; + } madv_dn; + +struct {/* unused reserved fields */ __u64 reserved1;__u64 reserved2;
@@ -84,9 +107,9 @@ struct uffd_msg {* Start at 0x12 and not at 0 to be more strict against bugs. */ #define UFFD_EVENT_PAGEFAULT 0x12 -#if 0 /* not available yet */ #define UFFD_EVENT_FORK 0x13 -#endif +#define UFFD_EVENT_REMAP 0x14 +#define UFFD_EVENT_MADVDONTNEED 0x15/* flags for UFFD_EVENT_PAGEFAULT */ #define UFFD_PAGEFAULT_FLAG_WRITE (1<<0)/* If this was a write fault */
@@ -104,11 +127,37 @@ struct uffdio_api {* Note: UFFD_EVENT_PAGEFAULT and UFFD_PAGEFAULT_FLAG_WRITE * are to be considered implicitly always enabled in all kernels as * long as the uffdio_api.api requested matches UFFD_API. +* +* UFFD_FEATURE_MISSING_HUGETLBFS means an UFFDIO_REGISTER +* with UFFDIO_REGISTER_MODE_MISSING mode will succeed on +* hugetlbfs virtual memory ranges. Adding or not adding +* UFFD_FEATURE_MISSING_HUGETLBFS to uffdio_api.features has +* no real functional effect after UFFDIO_API returns, but +* it's only useful for an initial feature set probe at +* UFFDIO_API time. There are two ways to use it: +* +* 1) by adding UFFD_FEATURE_MISSING_HUGETLBFS to the +* uffdio_api.features before calling UFFDIO_API, an error +* will be returned by UFFDIO_API on a kernel without +* hugetlbfs missing support +* +* 2) the UFFD_FEATURE_MISSING_HUGETLBFS can not be added in +* uffdio_api.features and instead it will be set by the +* kernel in the uffdio_api.features if the kernel supports +* it, so userland can later check if the feature flag is +* present in uffdio_api.features after UFFDIO_API +* succeeded. +* +* UFFD_FEATURE_MISSING_SHMEM works the same as +* UFFD_FEATURE_MISSING_HUGETLBFS, but it applies to shmem +* (i.e. tmpfs and other shmem based APIs). */ -#if 0 /* not available yet */ #define UFFD_FEATURE_PAGEFAULT_FLAG_WP (1<<0)#define UFFD_FEATURE_EVENT_FORK (1<<1) -#endif +#define UFFD_FEATURE_EVENT_REMAP (1<<2) +#define UFFD_FEATURE_EVENT_MADVDONTNEED (1<<3) +#define UFFD_FEATURE_MISSING_HUGETLBFS (1<<4) +#define UFFD_FEATURE_MISSING_SHMEM (1<<5)__u64 features;__u64 ioctls;
Signature · 1 line
2.9.3
PATCH v3 14/16 postcopy: Check for userfault+hugepage feature
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
We need extra Linux kernel support (~4.11) to support userfaults on hugetlbfs; check for them.
--- migration/postcopy-ram.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
migration/postcopy-ram.c +11 -1
@@ -81,6 +81,17 @@ static bool ufd_version_check(int ufd)return false; } +if (getpagesize () !=ram_pagesize_summary ()) { +bool have_hp = false; +/* We've got a huge page */ +#ifdef UFFD_FEATURE_MISSING_HUGETLBFS + have_hp = api_struct.features &UFFD_FEATURE_MISSING_HUGETLBFS ; +#endif +if (!have_hp) { +error_report ("Userfault on this host does not support huge pages" ); +return false; + } + }return true; }
@@ -115,7 +126,6 @@ bool postcopy_ram_supported_by_host(void)if (!ufd_version_check (ufd)) { goto out; } -/* TODO: Only allow huge pages if the kernel supports it */ /* * userfault and mlock don't go together; we'll put it back later if
Signature · 1 line
2.9.3
PATCH v3 15/16 postcopy: Add doc about hugepages and postcopy
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
--- docs/migration.txt | 13 +++++++++++++ 1 file changed, 13 insertions(+)
docs/migration.txt +13 -0
@@ -482,3 +482,16 @@ request for a page that has already been sent is ignored. Duplicate requests such as this can happen as a page is sent at about the same time the destination accesses it. +=== Postcopy with hugepages === + +Postcopy now works with hugetlbfs backed memory: + a) The linux kernel on the destination must support userfault on hugepages. + b) The huge-page configuration on the source and destination VMs must be + identical; i.e. RAMBlocks on both sides must use the same page size. + c) Note that -mem-path /dev/hugepages will fall back to allocating normal + RAM if it doesn't have enough hugepages, triggering (b) to fail. + Using -mem-prealloc enforces the allocation using hugepages. + d) Care should be taken with the size of hugepage used; postcopy with 2MB + hugepages works well, however 1GB hugepages are likely to be problematic + since it takes ~1 second to transfer a 1GB hugepage across a 10Gbps link, + and until the full page is transferred the destination thread is blocked.
Signature · 1 line
2.9.3
PATCH v3 16/16 postcopy: Add extra check for COPY function
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
As an extra sanity check, make sure the region we're registering can perform UFFDIO_COPY; the COPY will fail later but this gives a cleaner failure.
--- migration/postcopy-ram.c | 4 ++++ 1 file changed, 4 insertions(+)
migration/postcopy-ram.c +4 -0
@@ -378,6 +378,10 @@ static int ram_block_enable_notify(const char *block_name, void *host_addr,error_report ("%s userfault register: %s" , __func__,strerror (errno));return -1 ; } +if (!(reg_struct.ioctls & ((__u64 )1 << _UFFDIO_COPY))) { +error_report ("%s userfault: Region doesn't support COPY" , __func__); +return -1 ; + }return 0 ; }
Signature · 1 line
2.9.3
Re: [Qemu-devel] [PATCH v3 16/16] postcopy: Add extra check for COPY function
Quoted 17 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
As an extra sanity check, make sure the region we're registering can perform
UFFDIO_COPY; the COPY will fail later but this gives a cleaner failure.Signed-off-by Dr. David Alan Gilbert <[email protected]>--- migration/postcopy-ram.c | 4 ++++ 1 file changed, 4 insertions(+)migration/postcopy-ram.c +0
-0
migration/postcopy-ram.c static int ram_block_enable_notify(const char *block_name, void *host_addr, · line 387
Quoted 10 lines
migration/postcopy-ram.c +4
-0@@ -378,6 +378,10 @@ static int ram_block_enable_notify(const char *block_name, void *host_addr,error_report ("%s userfault register: %s" , __func__,strerror (errno));return -1 ; } +if (!(reg_struct.ioctls & ((__u64 )1 << _UFFDIO_COPY))) { +error_report ("%s userfault: Region doesn't support COPY" , __func__); +return -1 ; + }return 0 ; }