migration: clear the memory region dirty bitmap when skipping free pages
PATCH 1/1 migration: clear the memory region dirty bitmap when skipping free pages
When skipping free pages, their corresponding dirty bits in the memory region dirty bitmap need to be cleared. Otherwise the skipped pages will be sent in the next round after the migration thread syncs dirty bits from the memory region dirty bitmap.
migration_clear_memory_region_dirty_bitmap_range is put outside the bitmap_mutex, becasue memory_region_clear_dirty_bitmap is possible to block on the kvm slot mutex (don't want holding bitmap_mutex while blocked on another mutex), and clear_bmap_test_and_clear uses atomic operation.
--- capstone | 2 +- migration/ram.c | 73 +++++++++++++++++++++++++++++++++++++------------ slirp | 2 +- ui/keycodemapdb | 2 +- 4 files changed, 58 insertions(+), 21 deletions(-)
capstone +1 -1
@@ -1 +1 @@ -Subproject commit f8b1b833015a4ae47110ed068e0deb7106ced66d +Subproject commit 22ead3e0bfdb87516656453336160e0a37b066bf
migration/ram.c +55 -18
93 lines not on this page · raw message
slirp +1 -1
@@ -1 +1 @@ -Subproject commit 8f43a99191afb47ca3f3c6972f6306209f367ece +Subproject commit 2faae0f778f818fadc873308f983289df697eb93
ui/keycodemapdb +1 -1
@@ -1 +1 @@ -Subproject commit 6119e6e19a050df847418de7babe5166779955e4 +Subproject commit 320f92c36a80bfafc5d57834592a7be5fd79f104
Signature · 1 line
2.25.1
Quoted 7 lines · Wei Wang
When skipping free pages, their corresponding dirty bits in the memory region dirty bitmap need to be cleared. Otherwise the skipped pages will be sent in the next round after the migration thread syncs dirty bits from the memory region dirty bitmap.
migration_clear_memory_region_dirty_bitmap_rangeis put outside thebitmap_mutex, becasue
because?
Quoted 10 lines
memory_region_clear_dirty_bitmapis possible to block
on the kvm slot mutex (don't want holdingbitmap_mutexwhile blocked on another mutex), andclear_bmap_test_and_clearuses atomic operation.Cc David Hildenbrand <[email protected]>Cc Peter Xu <[email protected]>Reported-by David Hildenbrand <[email protected]>Signed-off-by Wei Wang <[email protected]>--- capstone | 2 +-
Seems unnecessary.
Quoted 3 lines
migration/ram.c | 73 +++++++++++++++++++++++++++++++++++++------------ slirp | 2 +- ui/keycodemapdb | 2 +-
These too.
Quoted 125 lines
4 files changed, 58 insertions(+), 21 deletions(-)capstone +1
-1@@ -1 +1 @@ -Subproject commit f8b1b833015a4ae47110ed068e0deb7106ced66d +Subproject commit 22ead3e0bfdb87516656453336160e0a37b066bfmigration/ram.c +55
-18@@ -789,6 +789,51 @@ unsigned long migration_bitmap_find_dirty(RAMState *rs, RAMBlock *rb,return find_next_bit (bitmap, size, start); } +static void migration_clear_memory_region_dirty_bitmap (RAMState *rs, +RAMBlock *rb, +unsigned long page) +{ +uint8_t shift; +hwaddr size, start; + +if (!rb->clear_bmap || !clear_bmap_test_and_clear (rb, page)) { +return ; + } + + shift = rb->clear_bmap_shift; +/* +* CLEAR_BITMAP_SHIFT_MIN should always guarantee this... this +* can make things easier sometimes since then start address +* of the small chunk will always be 64 pages aligned so the +* bitmap will always be aligned to unsigned long. We should +* even be able to remove this restriction but I'm simply +* keeping it. +*/ +assert (shift >=6 ); + + size =1ULL << (TARGET_PAGE_BITS + shift); + start = (((ram_addr_t )page) <<TARGET_PAGE_BITS ) & (-size); +trace_migration_bitmap_clear_dirty (rb->idstr, start, size, page); +memory_region_clear_dirty_bitmap (rb->mr, start, size); +} + +static void +migration_clear_memory_region_dirty_bitmap_range (RAMState *rs, +RAMBlock *rb, +unsigned long start, +unsigned long npages) +{ +unsigned long page_to_clear, i, nchunks; +unsigned long chunk_pages =1UL << rb->clear_bmap_shift; + + nchunks = (start + npages) / chunk_pages - start / chunk_pages +1 ; + +for (i =0 ; i < nchunks; i++) { + page_to_clear = start + i * chunk_pages; +migration_clear_memory_region_dirty_bitmap (rs, rb, page_to_clear); + } +} +static inline bool migration_bitmap_clear_dirty (RAMState *rs,RAMBlock *rb,unsigned long page)@@ -805,26 +850,9 @@ static inline bool migration_bitmap_clear_dirty(RAMState *rs,* the page in the chunk we clear the remote dirty bitmap for all. * Clearing it earlier won't be a problem, but too late will. */ -if (rb->clear_bmap &&clear_bmap_test_and_clear (rb, page)) { -uint8_t shift = rb->clear_bmap_shift; -hwaddr size =1ULL << (TARGET_PAGE_BITS + shift); -hwaddr start = (((ram_addr_t )page) <<TARGET_PAGE_BITS ) & (-size); - -/* -* CLEAR_BITMAP_SHIFT_MIN should always guarantee this... this -* can make things easier sometimes since then start address -* of the small chunk will always be 64 pages aligned so the -* bitmap will always be aligned to unsigned long. We should -* even be able to remove this restriction but I'm simply -* keeping it. -*/ -assert (shift >=6 ); -trace_migration_bitmap_clear_dirty (rb->idstr, start, size, page); -memory_region_clear_dirty_bitmap (rb->mr, start, size); - } +migration_clear_memory_region_dirty_bitmap (rs, rb, page); ret =test_and_clear_bit (page, rb->bmap); -if (ret) { rs->migration_dirty_pages--; }@@ -2742,6 +2770,15 @@ void qemu_guest_free_page_hint(void *addr, size_t len) start = offset >>TARGET_PAGE_BITS ; npages = used_len >>TARGET_PAGE_BITS ; +/* +* The skipped free pages are equavelent to be sent from clear_bmap's +* perspective, so clear the bits from the memory region bitmap which +* are initially set. Otherwise those skipped pages will be sent in +* the next round after syncing from the memory region bitmap. +*/ +migration_clear_memory_region_dirty_bitmap_range (ram_state, block, + start, npages); +qemu_mutex_lock (&ram_state->bitmap_mutex); ram_state->migration_dirty_pages -=bitmap_count_one_with_offset (block->bmap, start, npages);slirp +1
-1@@ -1 +1 @@ -Subproject commit 8f43a99191afb47ca3f3c6972f6306209f367ece +Subproject commit 2faae0f778f818fadc873308f983289df697eb93ui/keycodemapdb +1
-1@@ -1 +1 @@ -Subproject commit 6119e6e19a050df847418de7babe5166779955e4 +Subproject commit 320f92c36a80bfafc5d57834592a7be5fd79f104Signature · 1 line
2.25.1
Quoted 6 lines · Michael S. Tsirkin
Quoted 5 lines · Wei Wang
When skipping free pages, their corresponding dirty bits in the memory region dirty bitmap need to be cleared. Otherwise the skipped pages will be sent in the next round after the migration thread syncs dirty bits from the memory region dirty bitmap.
Quoted 8 lines
Quoted 2 lines
migration_clear_memory_region_dirty_bitmap_rangeis put outside thebitmap_mutex, becasuebecause?
Quoted 3 lines
memory_region_clear_dirty_bitmapis possible to block
on the kvm slot mutex (don't want holdingbitmap_mutexwhile blocked on another mutex), andclear_bmap_test_and_clearuses atomic operation.
How is that different from our existing caller?
Please either clean everything up, completely avoiding the lock (separate patch), or move it under the lock.
Or am I missing something important?
Signature · 3 lines
Thanks, David / dhildenb
Quoted 17 lines · David Hildenbrand
Quoted 6 lines · Michael S. Tsirkin
Quoted 5 lines · Wei Wang
When skipping free pages, their corresponding dirty bits in the memory region dirty bitmap need to be cleared. Otherwise the skipped pages will be sent in the next round after the migration thread syncs dirty bits from the memory region dirty bitmap.
Quoted 8 lines
Quoted 2 lines
migration_clear_memory_region_dirty_bitmap_rangeis put outside thebitmap_mutex, becasuebecause?
Quoted 3 lines
memory_region_clear_dirty_bitmapis possible to block on the kvm slot mutex (don't want holdingbitmap_mutexwhile blocked on another mutex), andclear_bmap_test_and_clearuses atomic operation.
Quoted 6 lines
How is that different from our existing caller?
Please either clean everything up, completely avoiding the lock (separate patch), or move it under the lock.
Or am I missing something important?
That seems ok to me and Peter to have it outside the lock. Not sure if Dave or Juan knows the reason why clear_bmap needs to be under the mutex given that it is atomic operation.
Best,
Wei
Quoted 18 lines · Wei W
Quoted 17 lines · David Hildenbrand
Quoted 14 lines · Michael S. Tsirkin
Quoted 7 lines · Wei Wang
When skipping free pages, their corresponding dirty bits in the memory region dirty bitmap need to be cleared. Otherwise the skipped pages will be sent in the next round after the migration thread syncs dirty bits from the memory region dirty bitmap.
migration_clear_memory_region_dirty_bitmap_rangeis put outside thebitmap_mutex, becasuebecause?
Quoted 3 lines
memory_region_clear_dirty_bitmapis possible to block on the kvm slot mutex (don't want holdingbitmap_mutexwhile blocked on another mutex), andclear_bmap_test_and_clearuses atomic operation.
Quoted 8 lines
Quoted 6 lines
How is that different from our existing caller?
Please either clean everything up, completely avoiding the lock (separate patch), or move it under the lock.
Or am I missing something important?
That seems ok to me and Peter to have it outside the lock. Not sure if Dave or Juan knows the reason why
clear_bmapneeds to be under the mutex given that it is atomic operation.
Yes it looks ok to not have the lock to me, but I still think it's easier to put all bitmap ops under the bitmap_mutex, so we handle clear_bmap/bmap the same way. It's also what we did in the existing code (although by accident).
Then we can replace clear_bmap atomic ops to normal mem accesses in a follow up patch. But it won't affect a huge lot - unlike normal bmap, clear_bmap is normally per 1g chunk so modifying clear_bmap happens much less frequently.
Atomic ops will be needed of course if we want a spinlock version of bitmap_mutex, however I still don't know whether that'll really help anything.
Thanks,
Signature · 1 line
Peter Xu