2013-10-14 17:13:59 +02:00
|
|
|
/*
|
|
|
|
* Declarations for cpu physical memory functions
|
|
|
|
*
|
|
|
|
* Copyright 2011 Red Hat, Inc. and/or its affiliates
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Avi Kivity <avi@redhat.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or
|
|
|
|
* later. See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This header is for use by exec.c and memory.c ONLY. Do not include it.
|
|
|
|
* The functions declared here will be removed soon.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef RAM_ADDR_H
|
|
|
|
#define RAM_ADDR_H
|
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
2019-08-12 07:23:31 +02:00
|
|
|
#include "cpu.h"
|
2013-10-14 17:13:59 +02:00
|
|
|
#include "hw/xen/xen.h"
|
2019-05-23 16:35:05 +02:00
|
|
|
#include "sysemu/tcg.h"
|
2016-12-20 17:31:36 +01:00
|
|
|
#include "exec/ramlist.h"
|
2013-10-14 17:13:59 +02:00
|
|
|
|
2015-08-14 12:25:14 +02:00
|
|
|
struct RAMBlock {
|
|
|
|
struct rcu_head rcu;
|
|
|
|
struct MemoryRegion *mr;
|
|
|
|
uint8_t *host;
|
2018-09-03 06:38:48 +02:00
|
|
|
uint8_t *colo_cache; /* For colo, VM's ram cache */
|
2015-08-14 12:25:14 +02:00
|
|
|
ram_addr_t offset;
|
|
|
|
ram_addr_t used_length;
|
|
|
|
ram_addr_t max_length;
|
|
|
|
void (*resized)(const char*, uint64_t length, void *host);
|
|
|
|
uint32_t flags;
|
|
|
|
/* Protected by iothread lock. */
|
|
|
|
char idstr[256];
|
|
|
|
/* RCU-enabled, writes protected by the ramlist lock */
|
|
|
|
QLIST_ENTRY(RAMBlock) next;
|
2016-12-20 17:31:36 +01:00
|
|
|
QLIST_HEAD(, RAMBlockNotifier) ramblock_notifiers;
|
2015-08-14 12:25:14 +02:00
|
|
|
int fd;
|
2016-09-29 21:09:37 +02:00
|
|
|
size_t page_size;
|
2017-03-22 15:18:04 +01:00
|
|
|
/* dirty bitmap used during migration */
|
|
|
|
unsigned long *bmap;
|
|
|
|
/* bitmap of pages that haven't been sent even 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 *unsentmap;
|
2017-10-05 13:13:20 +02:00
|
|
|
/* bitmap of already received pages in postcopy */
|
|
|
|
unsigned long *receivedmap;
|
migration: Split log_clear() into smaller chunks
Currently we are doing log_clear() right after log_sync() which mostly
keeps the old behavior when log_clear() was still part of log_sync().
This patch tries to further optimize the migration log_clear() code
path to split huge log_clear()s into smaller chunks.
We do this by spliting the whole guest memory region into memory
chunks, whose size is decided by MigrationState.clear_bitmap_shift (an
example will be given below). With that, we don't do the dirty bitmap
clear operation on the remote node (e.g., KVM) when we fetch the dirty
bitmap, instead we explicitly clear the dirty bitmap for the memory
chunk for each of the first time we send a page in that chunk.
Here comes an example.
Assuming the guest has 64G memory, then before this patch the KVM
ioctl KVM_CLEAR_DIRTY_LOG will be a single one covering 64G memory.
If after the patch, let's assume when the clear bitmap shift is 18,
then the memory chunk size on x86_64 will be 1UL<<18 * 4K = 1GB. Then
instead of sending a big 64G ioctl, we'll send 64 small ioctls, each
of the ioctl will cover 1G of the guest memory. For each of the 64
small ioctls, we'll only send if any of the page in that small chunk
was going to be sent right away.
Signed-off-by: Peter Xu <peterx@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190603065056.25211-12-peterx@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
2019-06-03 08:50:56 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* bitmap to track already cleared dirty bitmap. When the bit is
|
|
|
|
* set, it means the corresponding memory chunk needs a log-clear.
|
|
|
|
* Set this up to non-NULL to enable the capability to postpone
|
|
|
|
* and split clearing of dirty bitmap on the remote node (e.g.,
|
|
|
|
* KVM). The bitmap will be set only when doing global sync.
|
|
|
|
*
|
|
|
|
* NOTE: this bitmap is different comparing to the other bitmaps
|
|
|
|
* in that one bit can represent multiple guest pages (which is
|
|
|
|
* decided by the `clear_bmap_shift' variable below). On
|
|
|
|
* destination side, this should always be NULL, and the variable
|
|
|
|
* `clear_bmap_shift' is meaningless.
|
|
|
|
*/
|
|
|
|
unsigned long *clear_bmap;
|
|
|
|
uint8_t clear_bmap_shift;
|
2015-08-14 12:25:14 +02:00
|
|
|
};
|
|
|
|
|
migration: Split log_clear() into smaller chunks
Currently we are doing log_clear() right after log_sync() which mostly
keeps the old behavior when log_clear() was still part of log_sync().
This patch tries to further optimize the migration log_clear() code
path to split huge log_clear()s into smaller chunks.
We do this by spliting the whole guest memory region into memory
chunks, whose size is decided by MigrationState.clear_bitmap_shift (an
example will be given below). With that, we don't do the dirty bitmap
clear operation on the remote node (e.g., KVM) when we fetch the dirty
bitmap, instead we explicitly clear the dirty bitmap for the memory
chunk for each of the first time we send a page in that chunk.
Here comes an example.
Assuming the guest has 64G memory, then before this patch the KVM
ioctl KVM_CLEAR_DIRTY_LOG will be a single one covering 64G memory.
If after the patch, let's assume when the clear bitmap shift is 18,
then the memory chunk size on x86_64 will be 1UL<<18 * 4K = 1GB. Then
instead of sending a big 64G ioctl, we'll send 64 small ioctls, each
of the ioctl will cover 1G of the guest memory. For each of the 64
small ioctls, we'll only send if any of the page in that small chunk
was going to be sent right away.
Signed-off-by: Peter Xu <peterx@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190603065056.25211-12-peterx@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
2019-06-03 08:50:56 +02:00
|
|
|
/**
|
|
|
|
* clear_bmap_size: calculate clear bitmap size
|
|
|
|
*
|
|
|
|
* @pages: number of guest pages
|
|
|
|
* @shift: guest page number shift
|
|
|
|
*
|
|
|
|
* Returns: number of bits for the clear bitmap
|
|
|
|
*/
|
|
|
|
static inline long clear_bmap_size(uint64_t pages, uint8_t shift)
|
|
|
|
{
|
|
|
|
return DIV_ROUND_UP(pages, 1UL << shift);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clear_bmap_set: set clear bitmap for the page range
|
|
|
|
*
|
|
|
|
* @rb: the ramblock to operate on
|
|
|
|
* @start: the start page number
|
|
|
|
* @size: number of pages to set in the bitmap
|
|
|
|
*
|
|
|
|
* Returns: None
|
|
|
|
*/
|
|
|
|
static inline void clear_bmap_set(RAMBlock *rb, uint64_t start,
|
|
|
|
uint64_t npages)
|
|
|
|
{
|
|
|
|
uint8_t shift = rb->clear_bmap_shift;
|
|
|
|
|
|
|
|
bitmap_set_atomic(rb->clear_bmap, start >> shift,
|
|
|
|
clear_bmap_size(npages, shift));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clear_bmap_test_and_clear: test clear bitmap for the page, clear if set
|
|
|
|
*
|
|
|
|
* @rb: the ramblock to operate on
|
|
|
|
* @page: the page number to check
|
|
|
|
*
|
|
|
|
* Returns: true if the bit was set, false otherwise
|
|
|
|
*/
|
|
|
|
static inline bool clear_bmap_test_and_clear(RAMBlock *rb, uint64_t page)
|
|
|
|
{
|
|
|
|
uint8_t shift = rb->clear_bmap_shift;
|
|
|
|
|
|
|
|
return bitmap_test_and_clear_atomic(rb->clear_bmap, page >> shift, 1);
|
|
|
|
}
|
|
|
|
|
2016-01-15 04:37:41 +01:00
|
|
|
static inline bool offset_in_ramblock(RAMBlock *b, ram_addr_t offset)
|
|
|
|
{
|
|
|
|
return (b && b->host && offset < b->used_length) ? true : false;
|
|
|
|
}
|
|
|
|
|
2015-08-14 12:25:14 +02:00
|
|
|
static inline void *ramblock_ptr(RAMBlock *block, ram_addr_t offset)
|
|
|
|
{
|
2016-01-15 04:37:41 +01:00
|
|
|
assert(offset_in_ramblock(block, offset));
|
2015-08-14 12:25:14 +02:00
|
|
|
return (char *)block->host + offset;
|
|
|
|
}
|
|
|
|
|
2017-10-05 13:13:20 +02:00
|
|
|
static inline unsigned long int ramblock_recv_bitmap_offset(void *host_addr,
|
|
|
|
RAMBlock *rb)
|
|
|
|
{
|
|
|
|
uint64_t host_addr_offset =
|
|
|
|
(uint64_t)(uintptr_t)(host_addr - (void *)rb->host);
|
|
|
|
return host_addr_offset >> TARGET_PAGE_BITS;
|
|
|
|
}
|
|
|
|
|
2018-07-18 09:48:00 +02:00
|
|
|
bool ramblock_is_pmem(RAMBlock *rb);
|
|
|
|
|
2019-04-17 13:31:43 +02:00
|
|
|
long qemu_minrampagesize(void);
|
|
|
|
long qemu_maxrampagesize(void);
|
2018-07-18 09:47:58 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* qemu_ram_alloc_from_file,
|
|
|
|
* qemu_ram_alloc_from_fd: Allocate a ram block from the specified backing
|
|
|
|
* file or device
|
|
|
|
*
|
|
|
|
* Parameters:
|
|
|
|
* @size: the size in bytes of the ram block
|
|
|
|
* @mr: the memory region where the ram block is
|
|
|
|
* @ram_flags: specify the properties of the ram block, which can be one
|
|
|
|
* or bit-or of following values
|
|
|
|
* - RAM_SHARED: mmap the backing file or device with MAP_SHARED
|
2018-07-18 09:48:00 +02:00
|
|
|
* - RAM_PMEM: the backend @mem_path or @fd is persistent memory
|
2018-07-18 09:47:58 +02:00
|
|
|
* Other bits are ignored.
|
|
|
|
* @mem_path or @fd: specify the backing file or device
|
|
|
|
* @errp: pointer to Error*, to store an error if it happens
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* On success, return a pointer to the ram block.
|
|
|
|
* On failure, return NULL.
|
|
|
|
*/
|
2016-03-01 07:18:18 +01:00
|
|
|
RAMBlock *qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
|
2018-07-18 09:47:58 +02:00
|
|
|
uint32_t ram_flags, const char *mem_path,
|
2016-03-01 07:18:18 +01:00
|
|
|
Error **errp);
|
2017-06-02 16:12:23 +02:00
|
|
|
RAMBlock *qemu_ram_alloc_from_fd(ram_addr_t size, MemoryRegion *mr,
|
2018-07-18 09:47:58 +02:00
|
|
|
uint32_t ram_flags, int fd,
|
2017-06-02 16:12:23 +02:00
|
|
|
Error **errp);
|
2018-07-18 09:47:58 +02:00
|
|
|
|
2016-03-01 07:18:18 +01:00
|
|
|
RAMBlock *qemu_ram_alloc_from_ptr(ram_addr_t size, void *host,
|
|
|
|
MemoryRegion *mr, Error **errp);
|
2017-12-13 15:37:37 +01:00
|
|
|
RAMBlock *qemu_ram_alloc(ram_addr_t size, bool share, MemoryRegion *mr,
|
|
|
|
Error **errp);
|
2016-03-01 07:18:18 +01:00
|
|
|
RAMBlock *qemu_ram_alloc_resizeable(ram_addr_t size, ram_addr_t max_size,
|
|
|
|
void (*resized)(const char*,
|
|
|
|
uint64_t length,
|
|
|
|
void *host),
|
|
|
|
MemoryRegion *mr, Error **errp);
|
2016-03-01 07:18:22 +01:00
|
|
|
void qemu_ram_free(RAMBlock *block);
|
2013-10-14 17:13:59 +02:00
|
|
|
|
2016-05-10 04:04:59 +02:00
|
|
|
int qemu_ram_resize(RAMBlock *block, ram_addr_t newsize, Error **errp);
|
2014-11-12 13:27:41 +01:00
|
|
|
|
2015-03-23 11:56:01 +01:00
|
|
|
#define DIRTY_CLIENTS_ALL ((1 << DIRTY_MEMORY_NUM) - 1)
|
|
|
|
#define DIRTY_CLIENTS_NOCODE (DIRTY_CLIENTS_ALL & ~(1 << DIRTY_MEMORY_CODE))
|
|
|
|
|
2018-05-30 11:58:36 +02:00
|
|
|
void tb_invalidate_phys_range(ram_addr_t start, ram_addr_t end);
|
|
|
|
|
2013-10-14 17:13:59 +02:00
|
|
|
static inline bool cpu_physical_memory_get_dirty(ram_addr_t start,
|
|
|
|
ram_addr_t length,
|
|
|
|
unsigned client)
|
|
|
|
{
|
2016-01-25 14:33:20 +01:00
|
|
|
DirtyMemoryBlocks *blocks;
|
|
|
|
unsigned long end, page;
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long idx, offset, base;
|
2016-01-25 14:33:20 +01:00
|
|
|
bool dirty = false;
|
2013-10-14 17:13:59 +02:00
|
|
|
|
|
|
|
assert(client < DIRTY_MEMORY_NUM);
|
|
|
|
|
|
|
|
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
|
|
|
|
page = start >> TARGET_PAGE_BITS;
|
|
|
|
|
2016-01-25 14:33:20 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
|
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
idx = page / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
offset = page % DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
base = page - offset;
|
2016-01-25 14:33:20 +01:00
|
|
|
while (page < end) {
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE);
|
|
|
|
unsigned long num = next - base;
|
|
|
|
unsigned long found = find_next_bit(blocks->blocks[idx], num, offset);
|
|
|
|
if (found < num) {
|
2016-01-25 14:33:20 +01:00
|
|
|
dirty = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
page = next;
|
|
|
|
idx++;
|
|
|
|
offset = 0;
|
|
|
|
base += DIRTY_MEMORY_BLOCK_SIZE;
|
2016-01-25 14:33:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return dirty;
|
2013-10-14 17:13:59 +02:00
|
|
|
}
|
|
|
|
|
2015-04-22 13:48:25 +02:00
|
|
|
static inline bool cpu_physical_memory_all_dirty(ram_addr_t start,
|
2014-11-16 20:44:21 +01:00
|
|
|
ram_addr_t length,
|
|
|
|
unsigned client)
|
|
|
|
{
|
2016-01-25 14:33:20 +01:00
|
|
|
DirtyMemoryBlocks *blocks;
|
|
|
|
unsigned long end, page;
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long idx, offset, base;
|
2016-01-25 14:33:20 +01:00
|
|
|
bool dirty = true;
|
2014-11-16 20:44:21 +01:00
|
|
|
|
|
|
|
assert(client < DIRTY_MEMORY_NUM);
|
|
|
|
|
|
|
|
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
|
|
|
|
page = start >> TARGET_PAGE_BITS;
|
|
|
|
|
2016-01-25 14:33:20 +01:00
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
|
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
idx = page / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
offset = page % DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
base = page - offset;
|
2016-01-25 14:33:20 +01:00
|
|
|
while (page < end) {
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE);
|
|
|
|
unsigned long num = next - base;
|
|
|
|
unsigned long found = find_next_zero_bit(blocks->blocks[idx], num, offset);
|
|
|
|
if (found < num) {
|
2016-01-25 14:33:20 +01:00
|
|
|
dirty = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
page = next;
|
|
|
|
idx++;
|
|
|
|
offset = 0;
|
|
|
|
base += DIRTY_MEMORY_BLOCK_SIZE;
|
2016-01-25 14:33:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return dirty;
|
2014-11-16 20:44:21 +01:00
|
|
|
}
|
|
|
|
|
2013-10-14 17:13:59 +02:00
|
|
|
static inline bool cpu_physical_memory_get_dirty_flag(ram_addr_t addr,
|
|
|
|
unsigned client)
|
|
|
|
{
|
|
|
|
return cpu_physical_memory_get_dirty(addr, 1, client);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool cpu_physical_memory_is_clean(ram_addr_t addr)
|
|
|
|
{
|
|
|
|
bool vga = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_VGA);
|
|
|
|
bool code = cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_CODE);
|
|
|
|
bool migration =
|
|
|
|
cpu_physical_memory_get_dirty_flag(addr, DIRTY_MEMORY_MIGRATION);
|
|
|
|
return !(vga && code && migration);
|
|
|
|
}
|
|
|
|
|
2015-03-25 15:21:39 +01:00
|
|
|
static inline uint8_t cpu_physical_memory_range_includes_clean(ram_addr_t start,
|
|
|
|
ram_addr_t length,
|
|
|
|
uint8_t mask)
|
2014-11-16 20:44:21 +01:00
|
|
|
{
|
2015-03-25 15:21:39 +01:00
|
|
|
uint8_t ret = 0;
|
|
|
|
|
|
|
|
if (mask & (1 << DIRTY_MEMORY_VGA) &&
|
|
|
|
!cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_VGA)) {
|
|
|
|
ret |= (1 << DIRTY_MEMORY_VGA);
|
|
|
|
}
|
|
|
|
if (mask & (1 << DIRTY_MEMORY_CODE) &&
|
|
|
|
!cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_CODE)) {
|
|
|
|
ret |= (1 << DIRTY_MEMORY_CODE);
|
|
|
|
}
|
|
|
|
if (mask & (1 << DIRTY_MEMORY_MIGRATION) &&
|
|
|
|
!cpu_physical_memory_all_dirty(start, length, DIRTY_MEMORY_MIGRATION)) {
|
|
|
|
ret |= (1 << DIRTY_MEMORY_MIGRATION);
|
|
|
|
}
|
|
|
|
return ret;
|
2014-11-16 20:44:21 +01:00
|
|
|
}
|
|
|
|
|
2013-10-14 17:13:59 +02:00
|
|
|
static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr,
|
|
|
|
unsigned client)
|
|
|
|
{
|
2016-01-25 14:33:20 +01:00
|
|
|
unsigned long page, idx, offset;
|
|
|
|
DirtyMemoryBlocks *blocks;
|
|
|
|
|
2013-10-14 17:13:59 +02:00
|
|
|
assert(client < DIRTY_MEMORY_NUM);
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
page = addr >> TARGET_PAGE_BITS;
|
|
|
|
idx = page / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
offset = page % DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
|
|
|
|
|
|
|
|
set_bit_atomic(offset, blocks->blocks[idx]);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
2013-10-14 17:13:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
|
2015-03-23 11:56:01 +01:00
|
|
|
ram_addr_t length,
|
|
|
|
uint8_t mask)
|
2013-10-14 17:13:59 +02:00
|
|
|
{
|
2016-01-25 14:33:20 +01:00
|
|
|
DirtyMemoryBlocks *blocks[DIRTY_MEMORY_NUM];
|
2013-10-14 17:13:59 +02:00
|
|
|
unsigned long end, page;
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long idx, offset, base;
|
2016-01-25 14:33:20 +01:00
|
|
|
int i;
|
2013-10-14 17:13:59 +02:00
|
|
|
|
2016-01-25 15:13:47 +01:00
|
|
|
if (!mask && !xen_enabled()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-14 17:13:59 +02:00
|
|
|
end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
|
|
|
|
page = start >> TARGET_PAGE_BITS;
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
|
|
|
|
blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]);
|
2015-03-23 11:56:01 +01:00
|
|
|
}
|
2016-01-25 14:33:20 +01:00
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
idx = page / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
offset = page % DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
base = page - offset;
|
2016-01-25 14:33:20 +01:00
|
|
|
while (page < end) {
|
2016-02-10 15:11:45 +01:00
|
|
|
unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE);
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
if (likely(mask & (1 << DIRTY_MEMORY_MIGRATION))) {
|
|
|
|
bitmap_set_atomic(blocks[DIRTY_MEMORY_MIGRATION]->blocks[idx],
|
2016-02-10 15:11:45 +01:00
|
|
|
offset, next - page);
|
2016-01-25 14:33:20 +01:00
|
|
|
}
|
|
|
|
if (unlikely(mask & (1 << DIRTY_MEMORY_VGA))) {
|
|
|
|
bitmap_set_atomic(blocks[DIRTY_MEMORY_VGA]->blocks[idx],
|
2016-02-10 15:11:45 +01:00
|
|
|
offset, next - page);
|
2016-01-25 14:33:20 +01:00
|
|
|
}
|
|
|
|
if (unlikely(mask & (1 << DIRTY_MEMORY_CODE))) {
|
|
|
|
bitmap_set_atomic(blocks[DIRTY_MEMORY_CODE]->blocks[idx],
|
2016-02-10 15:11:45 +01:00
|
|
|
offset, next - page);
|
2016-01-25 14:33:20 +01:00
|
|
|
}
|
|
|
|
|
2016-02-10 15:11:45 +01:00
|
|
|
page = next;
|
|
|
|
idx++;
|
|
|
|
offset = 0;
|
|
|
|
base += DIRTY_MEMORY_BLOCK_SIZE;
|
2015-03-23 11:56:01 +01:00
|
|
|
}
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2017-03-07 11:55:31 +01:00
|
|
|
xen_hvm_modified_memory(start, length);
|
2013-10-14 17:13:59 +02:00
|
|
|
}
|
|
|
|
|
2014-01-14 07:00:28 +01:00
|
|
|
#if !defined(_WIN32)
|
2013-11-05 15:52:54 +01:00
|
|
|
static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap,
|
|
|
|
ram_addr_t start,
|
|
|
|
ram_addr_t pages)
|
|
|
|
{
|
2013-11-05 16:46:26 +01:00
|
|
|
unsigned long i, j;
|
2013-11-05 15:52:54 +01:00
|
|
|
unsigned long page_number, c;
|
|
|
|
hwaddr addr;
|
|
|
|
ram_addr_t ram_addr;
|
2013-11-05 16:46:26 +01:00
|
|
|
unsigned long len = (pages + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
|
2013-11-05 15:52:54 +01:00
|
|
|
unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE;
|
2013-11-05 16:46:26 +01:00
|
|
|
unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
|
2013-11-05 15:52:54 +01:00
|
|
|
|
2013-11-05 16:46:26 +01:00
|
|
|
/* start address is aligned at the start of a word? */
|
2014-01-30 13:03:50 +01:00
|
|
|
if ((((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) &&
|
|
|
|
(hpratio == 1)) {
|
2016-01-25 14:33:20 +01:00
|
|
|
unsigned long **blocks[DIRTY_MEMORY_NUM];
|
|
|
|
unsigned long idx;
|
|
|
|
unsigned long offset;
|
2013-11-05 16:46:26 +01:00
|
|
|
long k;
|
|
|
|
long nr = BITS_TO_LONGS(pages);
|
|
|
|
|
2016-01-25 14:33:20 +01:00
|
|
|
idx = (start >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
offset = BIT_WORD((start >> TARGET_PAGE_BITS) %
|
|
|
|
DIRTY_MEMORY_BLOCK_SIZE);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
for (i = 0; i < DIRTY_MEMORY_NUM; i++) {
|
|
|
|
blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks;
|
|
|
|
}
|
|
|
|
|
2013-11-05 16:46:26 +01:00
|
|
|
for (k = 0; k < nr; k++) {
|
|
|
|
if (bitmap[k]) {
|
|
|
|
unsigned long temp = leul_to_cpu(bitmap[k]);
|
|
|
|
|
2016-01-25 14:33:20 +01:00
|
|
|
atomic_or(&blocks[DIRTY_MEMORY_VGA][idx][offset], temp);
|
2019-06-03 08:50:48 +02:00
|
|
|
|
|
|
|
if (global_dirty_log) {
|
|
|
|
atomic_or(&blocks[DIRTY_MEMORY_MIGRATION][idx][offset],
|
|
|
|
temp);
|
|
|
|
}
|
|
|
|
|
2015-03-23 11:41:32 +01:00
|
|
|
if (tcg_enabled()) {
|
2016-01-25 14:33:20 +01:00
|
|
|
atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], temp);
|
2015-03-23 11:41:32 +01:00
|
|
|
}
|
2013-11-05 16:46:26 +01:00
|
|
|
}
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) {
|
|
|
|
offset = 0;
|
|
|
|
idx++;
|
|
|
|
}
|
2013-11-05 16:46:26 +01:00
|
|
|
}
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2017-03-07 11:55:31 +01:00
|
|
|
xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS);
|
2013-11-05 16:46:26 +01:00
|
|
|
} else {
|
2015-03-23 11:41:32 +01:00
|
|
|
uint8_t clients = tcg_enabled() ? DIRTY_CLIENTS_ALL : DIRTY_CLIENTS_NOCODE;
|
2019-06-03 08:50:48 +02:00
|
|
|
|
|
|
|
if (!global_dirty_log) {
|
|
|
|
clients &= ~(1 << DIRTY_MEMORY_MIGRATION);
|
|
|
|
}
|
|
|
|
|
2013-11-05 16:46:26 +01:00
|
|
|
/*
|
|
|
|
* bitmap-traveling is faster than memory-traveling (for addr...)
|
|
|
|
* especially when most of the memory is not dirty.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (bitmap[i] != 0) {
|
|
|
|
c = leul_to_cpu(bitmap[i]);
|
|
|
|
do {
|
2014-04-29 16:17:30 +02:00
|
|
|
j = ctzl(c);
|
2013-11-05 16:46:26 +01:00
|
|
|
c &= ~(1ul << j);
|
|
|
|
page_number = (i * HOST_LONG_BITS + j) * hpratio;
|
|
|
|
addr = page_number * TARGET_PAGE_SIZE;
|
|
|
|
ram_addr = start + addr;
|
|
|
|
cpu_physical_memory_set_dirty_range(ram_addr,
|
2015-03-23 11:41:32 +01:00
|
|
|
TARGET_PAGE_SIZE * hpratio, clients);
|
2013-11-05 16:46:26 +01:00
|
|
|
} while (c != 0);
|
|
|
|
}
|
2013-11-05 15:52:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-01-14 07:00:28 +01:00
|
|
|
#endif /* not _WIN32 */
|
2013-11-05 15:52:54 +01:00
|
|
|
|
2014-12-02 12:23:18 +01:00
|
|
|
bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start,
|
|
|
|
ram_addr_t length,
|
|
|
|
unsigned client);
|
2013-10-14 17:13:59 +02:00
|
|
|
|
2017-04-21 11:16:25 +02:00
|
|
|
DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty
|
2019-06-03 08:50:50 +02:00
|
|
|
(MemoryRegion *mr, hwaddr offset, hwaddr length, unsigned client);
|
2017-04-21 11:16:25 +02:00
|
|
|
|
|
|
|
bool cpu_physical_memory_snapshot_get_dirty(DirtyBitmapSnapshot *snap,
|
|
|
|
ram_addr_t start,
|
|
|
|
ram_addr_t length);
|
|
|
|
|
2014-11-17 16:54:07 +01:00
|
|
|
static inline void cpu_physical_memory_clear_dirty_range(ram_addr_t start,
|
|
|
|
ram_addr_t length)
|
|
|
|
{
|
2014-12-02 12:23:18 +01:00
|
|
|
cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_MIGRATION);
|
|
|
|
cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_VGA);
|
|
|
|
cpu_physical_memory_test_and_clear_dirty(start, length, DIRTY_MEMORY_CODE);
|
2014-11-17 16:54:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-06-03 08:50:46 +02:00
|
|
|
/* Called with RCU critical section */
|
2014-12-02 12:23:17 +01:00
|
|
|
static inline
|
2017-03-22 15:18:04 +01:00
|
|
|
uint64_t cpu_physical_memory_sync_dirty_bitmap(RAMBlock *rb,
|
2014-12-02 12:23:17 +01:00
|
|
|
ram_addr_t start,
|
2017-03-14 02:55:07 +01:00
|
|
|
ram_addr_t length,
|
2017-03-28 15:05:53 +02:00
|
|
|
uint64_t *real_dirty_pages)
|
2014-12-02 12:23:17 +01:00
|
|
|
{
|
|
|
|
ram_addr_t addr;
|
2017-07-24 18:51:25 +02:00
|
|
|
unsigned long word = BIT_WORD((start + rb->offset) >> TARGET_PAGE_BITS);
|
2014-12-02 12:23:17 +01:00
|
|
|
uint64_t num_dirty = 0;
|
2017-03-22 15:18:04 +01:00
|
|
|
unsigned long *dest = rb->bmap;
|
2014-12-02 12:23:17 +01:00
|
|
|
|
2018-01-03 19:33:36 +01:00
|
|
|
/* start address and length is aligned at the start of a word? */
|
2017-07-24 18:51:25 +02:00
|
|
|
if (((word * BITS_PER_LONG) << TARGET_PAGE_BITS) ==
|
2018-01-03 19:33:36 +01:00
|
|
|
(start + rb->offset) &&
|
|
|
|
!(length & ((BITS_PER_LONG << TARGET_PAGE_BITS) - 1))) {
|
2014-12-02 12:23:17 +01:00
|
|
|
int k;
|
|
|
|
int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS);
|
2016-01-25 14:33:20 +01:00
|
|
|
unsigned long * const *src;
|
2017-06-28 10:37:04 +02:00
|
|
|
unsigned long idx = (word * BITS_PER_LONG) / DIRTY_MEMORY_BLOCK_SIZE;
|
|
|
|
unsigned long offset = BIT_WORD((word * BITS_PER_LONG) %
|
2016-01-25 14:33:20 +01:00
|
|
|
DIRTY_MEMORY_BLOCK_SIZE);
|
2017-07-24 18:51:25 +02:00
|
|
|
unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
src = atomic_rcu_read(
|
|
|
|
&ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION])->blocks;
|
2014-12-02 12:23:17 +01:00
|
|
|
|
|
|
|
for (k = page; k < page + nr; k++) {
|
2016-01-25 14:33:20 +01:00
|
|
|
if (src[idx][offset]) {
|
|
|
|
unsigned long bits = atomic_xchg(&src[idx][offset], 0);
|
2014-12-02 12:23:17 +01:00
|
|
|
unsigned long new_dirty;
|
2017-03-14 02:55:07 +01:00
|
|
|
*real_dirty_pages += ctpopl(bits);
|
2014-12-02 12:23:17 +01:00
|
|
|
new_dirty = ~dest[k];
|
2014-12-02 12:23:19 +01:00
|
|
|
dest[k] |= bits;
|
|
|
|
new_dirty &= bits;
|
2014-12-02 12:23:17 +01:00
|
|
|
num_dirty += ctpopl(new_dirty);
|
|
|
|
}
|
2016-01-25 14:33:20 +01:00
|
|
|
|
|
|
|
if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) {
|
|
|
|
offset = 0;
|
|
|
|
idx++;
|
|
|
|
}
|
2014-12-02 12:23:17 +01:00
|
|
|
}
|
2019-06-03 08:50:51 +02:00
|
|
|
|
migration: Split log_clear() into smaller chunks
Currently we are doing log_clear() right after log_sync() which mostly
keeps the old behavior when log_clear() was still part of log_sync().
This patch tries to further optimize the migration log_clear() code
path to split huge log_clear()s into smaller chunks.
We do this by spliting the whole guest memory region into memory
chunks, whose size is decided by MigrationState.clear_bitmap_shift (an
example will be given below). With that, we don't do the dirty bitmap
clear operation on the remote node (e.g., KVM) when we fetch the dirty
bitmap, instead we explicitly clear the dirty bitmap for the memory
chunk for each of the first time we send a page in that chunk.
Here comes an example.
Assuming the guest has 64G memory, then before this patch the KVM
ioctl KVM_CLEAR_DIRTY_LOG will be a single one covering 64G memory.
If after the patch, let's assume when the clear bitmap shift is 18,
then the memory chunk size on x86_64 will be 1UL<<18 * 4K = 1GB. Then
instead of sending a big 64G ioctl, we'll send 64 small ioctls, each
of the ioctl will cover 1G of the guest memory. For each of the 64
small ioctls, we'll only send if any of the page in that small chunk
was going to be sent right away.
Signed-off-by: Peter Xu <peterx@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Message-Id: <20190603065056.25211-12-peterx@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
2019-06-03 08:50:56 +02:00
|
|
|
if (rb->clear_bmap) {
|
|
|
|
/*
|
|
|
|
* Postpone the dirty bitmap clear to the point before we
|
|
|
|
* really send the pages, also we will split the clear
|
|
|
|
* dirty procedure into smaller chunks.
|
|
|
|
*/
|
|
|
|
clear_bmap_set(rb, start >> TARGET_PAGE_BITS,
|
|
|
|
length >> TARGET_PAGE_BITS);
|
|
|
|
} else {
|
|
|
|
/* Slow path - still do that in a huge chunk */
|
|
|
|
memory_region_clear_dirty_bitmap(rb->mr, start, length);
|
|
|
|
}
|
2014-12-02 12:23:17 +01:00
|
|
|
} else {
|
2017-06-28 10:37:04 +02:00
|
|
|
ram_addr_t offset = rb->offset;
|
|
|
|
|
2014-12-02 12:23:17 +01:00
|
|
|
for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) {
|
2014-12-02 12:23:18 +01:00
|
|
|
if (cpu_physical_memory_test_and_clear_dirty(
|
2017-06-28 10:37:04 +02:00
|
|
|
start + addr + offset,
|
2014-12-02 12:23:18 +01:00
|
|
|
TARGET_PAGE_SIZE,
|
|
|
|
DIRTY_MEMORY_MIGRATION)) {
|
2017-03-14 02:55:07 +01:00
|
|
|
*real_dirty_pages += 1;
|
2014-12-02 12:23:17 +01:00
|
|
|
long k = (start + addr) >> TARGET_PAGE_BITS;
|
|
|
|
if (!test_and_set_bit(k, dest)) {
|
|
|
|
num_dirty++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return num_dirty;
|
|
|
|
}
|
2013-10-14 17:13:59 +02:00
|
|
|
#endif
|
|
|
|
#endif
|