OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

ram: Update all functions comments

Browse Source 
Added doc comments for existing functions comment and rewrite them in
a common style.

Signed-off-by: Juan Quintela <quintela@redhat.com>
Reviewed-by: Peter Xu <peterx@redhat.com>

--

Fix Peter Xu comments
Improve postcopy comments as per reviews.
This commit is contained in:
Juan Quintela 2017-03-23 15:06:39 +01:00
parent fa54abb8c2
commit 3d0684b2ad
1 changed files with 229 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

352
migration/ram.c
View File

@ -96,11 +96,17 @@ static void XBZRLE_cache_unlock(void)
qemu_mutex_unlock(&XBZRLE.lock); qemu_mutex_unlock(&XBZRLE.lock);
} }
/* /**
* called from qmp_migrate_set_cache_size in main thread, possibly while * xbzrle_cache_resize: resize the xbzrle cache
* a migration is in progress. *
* A running migration maybe using the cache and might finish during this * This function is called from qmp_migrate_set_cache_size in main
* call, hence changes to the cache are protected by XBZRLE.lock(). * thread, possibly while a migration is in progress. A running
* migration may be using the cache and might finish during this call,
* hence changes to the cache are protected by XBZRLE.lock().
*
* Returns the new_size or negative in case of error.
*
* @new_size: new cache size
*/ */
int64_t xbzrle_cache_resize(int64_t new_size) int64_t xbzrle_cache_resize(int64_t new_size)
{ {
@ -323,6 +329,7 @@ static inline void terminate_compression_threads(void)
int idx, thread_count; int idx, thread_count;
thread_count = migrate_compress_threads(); thread_count = migrate_compress_threads();
for (idx = 0; idx < thread_count; idx++) { for (idx = 0; idx < thread_count; idx++) {
qemu_mutex_lock(&comp_param[idx].mutex); qemu_mutex_lock(&comp_param[idx].mutex);
comp_param[idx].quit = true; comp_param[idx].quit = true;
@ -383,11 +390,11 @@ void migrate_compress_threads_create(void)
} }
/** /**
* save_page_header: Write page header to wire * save_page_header: write page header to wire
* *
* If this is the 1st block, it also writes the block identification * If this is the 1st block, it also writes the block identification
* *
* Returns: Number of bytes written * Returns the number of bytes written
* *
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: block that contains the page we want to send * @block: block that contains the page we want to send
@ -410,11 +417,14 @@ static size_t save_page_header(QEMUFile *f, RAMBlock *block, ram_addr_t offset)
return size; return size;
} }
/* Reduce amount of guest cpu execution to hopefully slow down memory writes. /**
* If guest dirty memory rate is reduced below the rate at which we can * mig_throttle_guest_down: throotle down the guest
* transfer pages to the destination then we should be able to complete *
* migration. Some workloads dirty memory way too fast and will not effectively * Reduce amount of guest cpu execution to hopefully slow down memory
* converge, even with auto-converge. * writes. If guest dirty memory rate is reduced below the rate at
* which we can transfer pages to the destination then we should be
* able to complete migration. Some workloads dirty memory way too
* fast and will not effectively converge, even with auto-converge.
*/ */
static void mig_throttle_guest_down(void) static void mig_throttle_guest_down(void)
{ {
@ -431,11 +441,16 @@ static void mig_throttle_guest_down(void)
} }
} }
/* Update the xbzrle cache to reflect a page that's been sent as all 0. /**
* xbzrle_cache_zero_page: insert a zero page in the XBZRLE cache
*
* @current_addr: address for the zero page
*
* Update the xbzrle cache to reflect a page that's been sent as all 0.
* The important thing is that a stale (not-yet-0'd) page be replaced * The important thing is that a stale (not-yet-0'd) page be replaced
* by the new data. * by the new data.
* As a bonus, if the page wasn't in the cache it gets added so that * As a bonus, if the page wasn't in the cache it gets added so that
* when a small write is made into the 0'd page it gets XBZRLE sent * when a small write is made into the 0'd page it gets XBZRLE sent.
*/ */
static void xbzrle_cache_zero_page(ram_addr_t current_addr) static void xbzrle_cache_zero_page(ram_addr_t current_addr)
{ {
@ -459,8 +474,8 @@ static void xbzrle_cache_zero_page(ram_addr_t current_addr)
* -1 means that xbzrle would be longer than normal * -1 means that xbzrle would be longer than normal
* *
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @current_data: * @current_data: pointer to the address of the page contents
* @current_addr: * @current_addr: addr of the page
* @block: block that contains the page we want to send * @block: block that contains the page we want to send
* @offset: offset inside the block for the page * @offset: offset inside the block for the page
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
@ -530,13 +545,17 @@ static int save_xbzrle_page(QEMUFile *f, uint8_t **current_data,
return 1; return 1;
} }
/* Called with rcu_read_lock() to protect migration_bitmap /**
* rb: The RAMBlock to search for dirty pages in * migration_bitmap_find_dirty: find the next dirty page from start
* 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 * Called with rcu_read_lock() to protect migration_bitmap
*
* Returns the byte offset within memory region of the start of a dirty page
*
* @rb: RAMBlock where to search for dirty pages
* @start: starting 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
*/ */
static inline static inline
ram_addr_t migration_bitmap_find_dirty(RAMBlock *rb, ram_addr_t migration_bitmap_find_dirty(RAMBlock *rb,
@ -600,10 +619,14 @@ static void migration_bitmap_sync_init(void)
iterations_prev = 0; 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 * ram_pagesize_summary: calculate all the pagesizes of a VM
* host page size. If it's got some huge pages then it's the OR *
* of all the different page sizes. * 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) uint64_t ram_pagesize_summary(void)
{ {
@ -693,9 +716,9 @@ static void migration_bitmap_sync(void)
} }
/** /**
* save_zero_page: Send the zero page to the stream * save_zero_page: send the zero page to the stream
* *
* Returns: Number of pages written. * Returns the number of pages written.
* *
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: block that contains the page we want to send * @block: block that contains the page we want to send
@ -731,14 +754,14 @@ static void ram_release_pages(MigrationState *ms, const char *block_name,
} }
/** /**
* ram_save_page: Send the given page to the stream * ram_save_page: send the given page to the stream
* *
* Returns: Number of pages written. * Returns the number of pages written.
* < 0 - error * < 0 - error
* >=0 - Number of pages written - this might legally be 0 * >=0 - Number of pages written - this might legally be 0
* if xbzrle noticed the page was the same. * if xbzrle noticed the page was the same.
* *
* @ms: The current migration state. * @ms: current migration state
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: block that contains the page we want to send * @block: block that contains the page we want to send
* @offset: offset inside the block for the page * @offset: offset inside the block for the page
@ -921,9 +944,9 @@ static int compress_page_with_multi_thread(QEMUFile *f, RAMBlock *block,
/** /**
* ram_save_compressed_page: compress the given page and send it to the stream * ram_save_compressed_page: compress the given page and send it to the stream
* *
* Returns: Number of pages written. * Returns the number of pages written.
* *
* @ms: The current migration state. * @ms: current migration state
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: block that contains the page we want to send * @block: block that contains the page we want to send
* @offset: offset inside the block for the page * @offset: offset inside the block for the page
@ -1000,17 +1023,17 @@ static int ram_save_compressed_page(MigrationState *ms, QEMUFile *f,
return pages; return pages;
} }
/* /**
* Find the next dirty page and update any state associated with * find_dirty_block: find the next dirty page and update any state
* the search process. * associated with the search process.
* *
* Returns: True if a page is found * Returns if a page is found
* *
* @f: Current migration stream. * @f: QEMUFile where to send the data
* @pss: Data about the state of the current dirty page scan. * @pss: data about the state of the current dirty page scan
* @*again: Set to false if the search has scanned the whole of RAM * @again: set to false if the search has scanned the whole of RAM
* *ram_addr_abs: Pointer into which to store the address of the dirty page * @ram_addr_abs: pointer into which to store the address of the dirty page
* within the global ram_addr space * within the global ram_addr space
*/ */
static bool find_dirty_block(QEMUFile *f, PageSearchStatus *pss, static bool find_dirty_block(QEMUFile *f, PageSearchStatus *pss,
bool *again, ram_addr_t *ram_addr_abs) bool *again, ram_addr_t *ram_addr_abs)
@ -1055,13 +1078,17 @@ static bool find_dirty_block(QEMUFile *f, PageSearchStatus *pss,
} }
} }
/* /**
* Helper for 'get_queued_page' - gets a page off the queue * unqueue_page: gets a page of the queue
* ms: MigrationState in
* *offset: Used to return the offset within the RAMBlock
* ram_addr_abs: global offset in the dirty/sent bitmaps
* *
* Returns: block (or NULL if none available) * Helper for 'get_queued_page' - gets a page off the queue
*
* Returns the block of the page (or NULL if none available)
*
* @ms: current migration state
* @offset: used to return the offset within the RAMBlock
* @ram_addr_abs: pointer into which to store the address of the dirty page
* within the global ram_addr space
*/ */
static RAMBlock *unqueue_page(MigrationState *ms, ram_addr_t *offset, static RAMBlock *unqueue_page(MigrationState *ms, ram_addr_t *offset,
ram_addr_t *ram_addr_abs) ram_addr_t *ram_addr_abs)
@ -1091,15 +1118,17 @@ static RAMBlock *unqueue_page(MigrationState *ms, ram_addr_t *offset,
return block; return block;
} }
/* /**
* Unqueue a page from the queue fed by postcopy page requests; skips pages * get_queued_page: unqueue a page from the postocpy requests
* that are already sent (!dirty)
* *
* ms: MigrationState in * Skips pages that are already sent (!dirty)
* pss: PageSearchStatus structure updated with found block/offset
* ram_addr_abs: global offset in the dirty/sent bitmaps
* *
* Returns: true if a queued page is found * Returns if a queued page is found
*
* @ms: current migration state
* @pss: data about the state of the current dirty page scan
* @ram_addr_abs: pointer into which to store the address of the dirty page
* within the global ram_addr space
*/ */
static bool get_queued_page(MigrationState *ms, PageSearchStatus *pss, static bool get_queued_page(MigrationState *ms, PageSearchStatus *pss,
ram_addr_t *ram_addr_abs) ram_addr_t *ram_addr_abs)
@ -1157,11 +1186,12 @@ static bool get_queued_page(MigrationState *ms, PageSearchStatus *pss,
} }
/** /**
* flush_page_queue: Flush any remaining pages in the ram request queue * flush_page_queue: flush any remaining pages in the ram request queue
* it should be empty at the end anyway, but in error cases there may be
* some left.
* *
* ms: MigrationState * It should be empty at the end anyway, but in error cases there may
* be some left. in case that there is any page left, we drop it.
*
* @ms: current migration state
*/ */
void flush_page_queue(MigrationState *ms) void flush_page_queue(MigrationState *ms)
{ {
@ -1179,12 +1209,17 @@ void flush_page_queue(MigrationState *ms)
} }
/** /**
* Queue the pages for transmission, e.g. a request from postcopy destination * ram_save_queue_pages: queue the page for transmission
* ms: MigrationStatus in which the queue is held *
* rbname: The RAMBlock the request is for - may be NULL (to mean reuse last) * A request from postcopy destination for example.
* start: Offset from the start of the RAMBlock *
* len: Length (in bytes) to send * Returns zero on success or negative on error
* Return: 0 on success *
* @ms: current migration state
* @rbname: Name of the RAMBLock of the request. NULL means the
* same that last one.
* @start: starting address from the start of the RAMBlock
* @len: length (in bytes) to send
*/ */
int ram_save_queue_pages(MigrationState *ms, const char *rbname, int ram_save_queue_pages(MigrationState *ms, const char *rbname,
ram_addr_t start, ram_addr_t len) ram_addr_t start, ram_addr_t len)
@ -1243,17 +1278,16 @@ err:
} }
/** /**
* ram_save_target_page: Save one target page * ram_save_target_page: save one target page
* *
* Returns the number of pages written
* *
* @ms: current migration state
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: pointer to block that contains the page we want to send * @pss: data about the page we want to send
* @offset: offset inside the block for the page;
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
* @bytes_transferred: increase it with the number of transferred bytes * @bytes_transferred: increase it with the number of transferred bytes
* @dirty_ram_abs: Address of the start of the dirty page in ram_addr_t space * @dirty_ram_abs: address of the start of the dirty page in ram_addr_t space
*
* Returns: Number of pages written.
*/ */
static int ram_save_target_page(MigrationState *ms, QEMUFile *f, static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
PageSearchStatus *pss, PageSearchStatus *pss,
@ -1295,20 +1329,19 @@ static int ram_save_target_page(MigrationState *ms, QEMUFile *f,
} }
/** /**
* ram_save_host_page: Starting at *offset send pages up to the end * ram_save_host_page: save a whole host page
* of the current host page. It's valid for the initial
* 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. * Starting at *offset send pages up to the end of the current host
* page. It's valid for the initial 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 the number of pages written or negative on error
*
* @ms: current migration state
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @block: pointer to block that contains the page we want to send * @pss: data about the page we want to send
* @offset: offset inside the block for the page; updated to last target page
* sent
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
* @bytes_transferred: increase it with the number of transferred bytes * @bytes_transferred: increase it with the number of transferred bytes
* @dirty_ram_abs: Address of the start of the dirty page in ram_addr_t space * @dirty_ram_abs: Address of the start of the dirty page in ram_addr_t space
@ -1340,12 +1373,11 @@ static int ram_save_host_page(MigrationState *ms, QEMUFile *f,
} }
/** /**
* ram_find_and_save_block: Finds a dirty page and sends it to f * ram_find_and_save_block: finds a dirty page and sends it to f
* *
* Called within an RCU critical section. * Called within an RCU critical section.
* *
* Returns: The number of pages written * Returns the number of pages written where zero means no dirty pages
* 0 means no dirty pages
* *
* @f: QEMUFile where to send the data * @f: QEMUFile where to send the data
* @last_stage: if we are at the completion stage * @last_stage: if we are at the completion stage
@ -1580,12 +1612,19 @@ void ram_postcopy_migrated_memory_release(MigrationState *ms)
} }
} }
/* /**
* postcopy_send_discard_bm_ram: discard a RAMBlock
*
* Returns zero on success
*
* Callback from postcopy_each_ram_send_discard for each RAMBlock * Callback from postcopy_each_ram_send_discard for each RAMBlock
* Note: At this point the 'unsentmap' is the processed bitmap combined * Note: At this point the 'unsentmap' is the processed bitmap combined
* with the dirtymap; so a '1' means it's either dirty or unsent. * with the dirtymap; so a '1' means it's either dirty or unsent.
* start,length: Indexes into the bitmap for the first bit *
* representing the named block and length in target-pages * @ms: current migration state
* @pds: state for postcopy
* @start: RAMBlock starting page
* @length: RAMBlock size
*/ */
static int postcopy_send_discard_bm_ram(MigrationState *ms, static int postcopy_send_discard_bm_ram(MigrationState *ms,
PostcopyDiscardState *pds, PostcopyDiscardState *pds,
@ -1621,13 +1660,18 @@ static int postcopy_send_discard_bm_ram(MigrationState *ms,
return 0; return 0;
} }
/* /**
* postcopy_each_ram_send_discard: discard all RAMBlocks
*
* Returns 0 for success or negative for error
*
* Utility for the outgoing postcopy code. * Utility for the outgoing postcopy code.
* Calls postcopy_send_discard_bm_ram for each RAMBlock * Calls postcopy_send_discard_bm_ram for each RAMBlock
* passing it bitmap indexes and name. * passing it bitmap indexes and name.
* Returns: 0 on success
* (qemu_ram_foreach_block ends up passing unscaled lengths * (qemu_ram_foreach_block ends up passing unscaled lengths
* which would mean postcopy code would have to deal with target page) * which would mean postcopy code would have to deal with target page)
*
* @ms: current migration state
*/ */
static int postcopy_each_ram_send_discard(MigrationState *ms) static int postcopy_each_ram_send_discard(MigrationState *ms)
{ {
@ -1656,17 +1700,21 @@ static int postcopy_each_ram_send_discard(MigrationState *ms)
return 0; return 0;
} }
/* /**
* Helper for postcopy_chunk_hostpages; it's called twice to cleanup * postcopy_chunk_hostpages_pass: canocalize bitmap in hostpages
* the two bitmaps, that are similar, but one is inverted.
* *
* We search for runs of target-pages that don't start or end on a * Helper for postcopy_chunk_hostpages; it's called twice to
* host page boundary; * canonicalize the two bitmaps, that are similar, but one is
* unsent_pass=true: Cleans up partially unsent host pages by searching * inverted.
* the unsentmap
* unsent_pass=false: Cleans up partially dirty host pages by searching
* the main migration bitmap
* *
* Postcopy requires that all target pages in a hostpage are dirty or
* clean, not a mix. This function canonicalizes the bitmaps.
*
* @ms: current migration state
* @unsent_pass: if true we need to canonicalize partially unsent host pages
* otherwise we need to canonicalize partially dirty host pages
* @block: block that contains the page we want to canonicalize
* @pds: state for postcopy
*/ */
static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass, static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
RAMBlock *block, RAMBlock *block,
@ -1784,14 +1832,18 @@ static void postcopy_chunk_hostpages_pass(MigrationState *ms, bool unsent_pass,
} }
} }
/* /**
* postcopy_chuck_hostpages: discrad any partially sent host page
*
* Utility for the outgoing postcopy code. * Utility for the outgoing postcopy code.
* *
* Discard any partially sent host-page size chunks, mark any partially * Discard any partially sent host-page size chunks, mark any partially
* dirty host-page size chunks as all dirty. In this case the host-page * 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 * is the host-page for the particular RAMBlock, i.e. it might be a huge page
* *
* Returns: 0 on success * Returns zero on success
*
* @ms: current migration state
*/ */
static int postcopy_chunk_hostpages(MigrationState *ms) static int postcopy_chunk_hostpages(MigrationState *ms)
{ {
@ -1822,7 +1874,11 @@ static int postcopy_chunk_hostpages(MigrationState *ms)
return 0; return 0;
} }
/* /**
* ram_postcopy_send_discard_bitmap: transmit the discard bitmap
*
* Returns zero on success
*
* Transmit the set of pages to be discarded after precopy to the target * Transmit the set of pages to be discarded after precopy to the target
* these are pages that: * these are pages that:
* a) Have been previously transmitted but are now dirty again * a) Have been previously transmitted but are now dirty again
@ -1830,6 +1886,8 @@ static int postcopy_chunk_hostpages(MigrationState *ms)
* any pages on the destination that have been mapped by background * any pages on the destination that have been mapped by background
* tasks get discarded (transparent huge pages is the specific concern) * tasks get discarded (transparent huge pages is the specific concern)
* Hopefully this is pretty sparse * Hopefully this is pretty sparse
*
* @ms: current migration state
*/ */
int ram_postcopy_send_discard_bitmap(MigrationState *ms) int ram_postcopy_send_discard_bitmap(MigrationState *ms)
{ {
@ -1878,13 +1936,16 @@ int ram_postcopy_send_discard_bitmap(MigrationState *ms)
return ret; return ret;
} }
/* /**
* At the start of the postcopy phase of migration, any now-dirty * ram_discard_range: discard dirtied pages at the beginning of postcopy
* precopied pages are discarded.
* *
* start, length describe a byte address range within the RAMBlock * Returns zero on success
* *
* Returns 0 on success. * @mis: current migration incoming state
* @block_name: Name of the RAMBlock of the request. NULL means the
* same that last one.
* @start: RAMBlock starting page
* @length: RAMBlock size
*/ */
int ram_discard_range(MigrationIncomingState *mis, int ram_discard_range(MigrationIncomingState *mis,
const char *block_name, const char *block_name,
@ -1987,12 +2048,21 @@ static int ram_save_init_globals(void)
return 0; return 0;
} }
/* Each of ram_save_setup, ram_save_iterate and ram_save_complete has /*
* Each of ram_save_setup, ram_save_iterate and ram_save_complete has
* long-running RCU critical section. When rcu-reclaims in the code * long-running RCU critical section. When rcu-reclaims in the code
* start to become numerous it will be necessary to reduce the * start to become numerous it will be necessary to reduce the
* granularity of these critical sections. * granularity of these critical sections.
*/ */
/**
* ram_save_setup: Setup RAM for migration
*
* Returns zero to indicate success and negative for error
*
* @f: QEMUFile where to send the data
* @opaque: RAMState pointer
*/
static int ram_save_setup(QEMUFile *f, void *opaque) static int ram_save_setup(QEMUFile *f, void *opaque)
{ {
RAMBlock *block; RAMBlock *block;
@ -2027,6 +2097,14 @@ static int ram_save_setup(QEMUFile *f, void *opaque)
return 0; return 0;
} }
/**
* ram_save_iterate: iterative stage for migration
*
* Returns zero to indicate success and negative for error
*
* @f: QEMUFile where to send the data
* @opaque: RAMState pointer
*/
static int ram_save_iterate(QEMUFile *f, void *opaque) static int ram_save_iterate(QEMUFile *f, void *opaque)
{ {
int ret; int ret;
@ -2091,7 +2169,16 @@ static int ram_save_iterate(QEMUFile *f, void *opaque)
return done; return done;
} }
/* Called with iothread lock */ /**
* ram_save_complete: function called to send the remaining amount of ram
*
* Returns zero to indicate success
*
* Called with iothread lock
*
* @f: QEMUFile where to send the data
* @opaque: RAMState pointer
*/
static int ram_save_complete(QEMUFile *f, void *opaque) static int ram_save_complete(QEMUFile *f, void *opaque)
{ {
rcu_read_lock(); rcu_read_lock();
@ -2185,17 +2272,17 @@ static int load_xbzrle(QEMUFile *f, ram_addr_t addr, void *host)
return 0; return 0;
} }
/* Must be called from within a rcu critical section. /**
* Returns a pointer from within the RCU-protected ram_list. * ram_block_from_stream: read a RAMBlock id from the migration stream
*/
/*
* Read a RAMBlock ID from the stream f.
* *
* f: Stream to read from * Must be called from within a rcu critical section.
* flags: Page flags (mostly to see if it's a continuation of previous block) *
* Returns a pointer from within the RCU-protected ram_list.
*
* @f: QEMUFile where to read the data from
* @flags: Page flags (mostly to see if it's a continuation of previous block)
*/ */
static inline RAMBlock *ram_block_from_stream(QEMUFile *f, static inline RAMBlock *ram_block_from_stream(QEMUFile *f, int flags)
int flags)
{ {
static RAMBlock *block = NULL; static RAMBlock *block = NULL;
char id[256]; char id[256];
@ -2232,9 +2319,15 @@ static inline void *host_from_ram_block_offset(RAMBlock *block,
return block->host + offset; return block->host + offset;
} }
/* /**
* ram_handle_compressed: handle the zero page case
*
* If a page (or a whole RDMA chunk) has been * If a page (or a whole RDMA chunk) has been
* determined to be zero, then zap it. * determined to be zero, then zap it.
*
* @host: host address for the zero page
* @ch: what the page is filled from. We only support zero
* @size: size of the zero page
*/ */
void ram_handle_compressed(void *host, uint8_t ch, uint64_t size) void ram_handle_compressed(void *host, uint8_t ch, uint64_t size)
{ {
@ -2373,9 +2466,16 @@ static void decompress_data_with_multi_threads(QEMUFile *f,
qemu_mutex_unlock(&decomp_done_lock); qemu_mutex_unlock(&decomp_done_lock);
} }
/* /**
* Allocate data structures etc needed by incoming migration with postcopy-ram * ram_postcopy_incoming_init: allocate postcopy data structures
* postcopy-ram's similarly names postcopy_ram_incoming_init does the work *
* Returns 0 for success and negative if there was one error
*
* @mis: current migration incoming state
*
* Allocate data structures etc needed by incoming migration with
* postcopy-ram. postcopy-ram's similarly names
* postcopy_ram_incoming_init does the work.
*/ */
int ram_postcopy_incoming_init(MigrationIncomingState *mis) int ram_postcopy_incoming_init(MigrationIncomingState *mis)
{ {
@ -2384,9 +2484,15 @@ int ram_postcopy_incoming_init(MigrationIncomingState *mis)
return postcopy_ram_incoming_init(mis, ram_pages); return postcopy_ram_incoming_init(mis, ram_pages);
} }
/* /**
* ram_load_postcopy: load a page in postcopy case
*
* Returns 0 for success or -errno in case of error
*
* Called in postcopy mode by ram_load(). * Called in postcopy mode by ram_load().
* rcu_read_lock is taken prior to this being called. * rcu_read_lock is taken prior to this being called.
*
* @f: QEMUFile where to send the data
*/ */
static int ram_load_postcopy(QEMUFile *f) static int ram_load_postcopy(QEMUFile *f)
{ {