和 MemoryListener 有一定的关系。

看一下这个！KVM同步脏页位图到Qemu

记住一共有四部分，所以需要三次同步才能最终到 RAMBlock 里：

• KVM 里的 memslot->dirty_bitmap。
• QEMU 里的 KVMSlot.dirty_bmap 记录每一个 KVMSlot 的信息。
• QEMU 里的 ram_list.dirty_memory 记录全局的信息。
• QEMU 里的 rb->bmap 记录每一个 RAMBlock 的 bitmap 信息。

QEMU 的 rb->bmap：

• 在刚开始被设置为全 1，这是为了在迁移的初始阶段，保证把所有的 page 发送过去，这一步是 QEMU 完成的。
• 在 page 内容被更新时（比如 guest 写了这个 page），dirty bitmap 其实是被 KVM 更新的，KVM 里也维护了一个 bitmap。然后在每一个迁移的 iteration 结束的时候可能 sync 到 QEMU（当根据旧的 dirty bitmap 信息判断可能可以进入到 blackout 阶段时，因为如果旧的 dirty-bitmap 都还没有迁移完成，那也没有必要 sync 新的了）。
• clear 的话是在 QEMU clear 的？

// 每一轮 iteration
migration_iteration_run
    qemu_savevm_state_pending_exact
        ops->state_pending_exact // ram_state_pending_exact
            migration_bitmap_sync_precopy // this is the point to sync with KVM

bmap 的类型是 unsigned long *，是一个 arrary, 这个 arrary 的 value 是 long 的类型，这个 long 类型的每一 bit 表示的都是一个 page dirty or not。所以可见这个 arrary 的 index 并不是页号，而应该是一个 index 能够表示 sizeof(long) 个 page 的 dirty 状态。

KVM 提供了两个主要的 ioctl 来处理 dirty page tracking 相关的功能，一个是 KVM_GET_DIRTY_LOG，另一个是 KVM_CLEAR_DIRTY_LOG。当没有 enable KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 的时候，KVM_GET_DIRTY_LOG 会自动 write protect dirty 的 page，当 enable 之后，需要通过 KVM_CLEAR_DIRTY_LOG 来 write protect 相应的 page。

memory_global_dirty_log_start() QEMU

每次调用这个函数，都是在往 global_dirty_tracking 上加 flag bit。 第一次从 0 flag 到 non-zero flag 的时候，会调用一些函数：

// 三个调用的地方，参数不同
ram_init_bitmaps
    memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION);
calculate_dirtyrate_dirty_bitmap
    memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE);
global_dirty_log_change
    memory_global_dirty_log_start(flag);

void memory_global_dirty_log_start(unsigned int flags)
{
    //...
    // 先不管这个
    if (vmstate_change) {
        /* If there is postponed stop(), operate on it first */
        postponed_stop_flags &= ~flags;
        memory_global_dirty_log_stop_postponed_run();
    }

    // 把 global_dirty_tracking 中有的 flag 从 flags 中去掉
    // 因此剩下的是 flags 中有但是 global_dirty_tracking 中没有的
    // 通俗理解为我们 flags 变成了我们要加到 global_dirty_tracking 里的 flags
    flags &= ~global_dirty_tracking;
    // 如前所述，表示什么也没有加，直接 return 就好了
    if (!flags)
        return;

    //...
    // snapshot 一下 global_dirty_tracking
    old_flags = global_dirty_tracking;
    // 如前所述，把 flag 加上去
    global_dirty_tracking |= flags;
    //...

    // 如果是从 0 加上来的，那么调用下面函数
    if (!old_flags) {
        // 从前往后调用 memory_listeners 这个全局列表里的所有 listener 的 log_global_start() 函数。
        MEMORY_LISTENER_CALL_GLOBAL(log_global_start, Forward);
        // 没做什么
        memory_region_transaction_begin();
        memory_region_update_pending = true;
        memory_region_transaction_commit();
    }
}

memory_global_dirty_log_stop() / memory_global_dirty_log_do_stop() QEMU

每次调用这个函数，都是在往 global_dirty_tracking 上减 flag bit。 第一次减到 0 flag 的时候，会调用一些函数。

从函数的设计上也可以看出，此函数和对应的 log_start() 函数都是可以嵌套的，也就是可以：

// 前半段 flags 只会增加，后半段 flags 只会减少
memory_global_dirty_log_start
    memory_global_dirty_log_start
        memory_global_dirty_log_stop
        memory_global_dirty_log_start
    memory_global_dirty_log_start
memory_global_dirty_log_start

global_dirty_log_change
    memory_global_dirty_log_stop(flag);
ram_save_cleanup
    memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION);
global_dirty_log_sync
    memory_global_dirty_log_stop(flag);

void memory_global_dirty_log_stop(unsigned int flags)
{
    // 表示 VM 现在没在 run（并不是此时此刻）
    // postpone
    if (!runstate_is_running()) {
        /* Postpone the dirty log stop, e.g., to when VM starts again */
        if (vmstate_change) {
            /* Batch with previous postponed flags */
            postponed_stop_flags |= flags;
        } else {
            postponed_stop_flags = flags;
            vmstate_change = qemu_add_vm_change_state_handler(
                memory_vm_change_state_handler, NULL);
        }
        return;
    }

    memory_global_dirty_log_do_stop(flags);
}

static void memory_global_dirty_log_do_stop(unsigned int flags)
{
    //...
    // 把 flags 里有的 bit 都去掉
    global_dirty_tracking &= ~flags;
    //...
    // 如果变成了 0，调用一些函数
    if (!global_dirty_tracking) {
        memory_region_transaction_begin();
        memory_region_update_pending = true;
        memory_region_transaction_commit();
        // **从后往前**调用 memory_listeners 这个全局列表里的所有 listener 的 log_global_stop() 函数。
        MEMORY_LISTENER_CALL_GLOBAL(log_global_stop, Reverse);
    }
}

migration_bitmap_sync_precopy() / migration_bitmap_sync() / Dirty bitmap from KVM to QEMU

这个函数负责以下两步：

• 先从 KVM 到 QEMU 的 ram_list->dirty_memory，
  • 先把 KVM 里的 dirty 信息同步到 KVMSlot->dirty_bmap（这一步涉及到用 dirty ring 还是 dirty bitmap）
  • 再把 KVMSlot->dirty_bmap 的信息同步到 ram_list->dirty_memory。
• 再从 QEMU 的 ram_list->dirty_memory 到每一个 rb->bmap（这一步就是统一的 bitmap）。

static void migration_bitmap_sync_precopy(RAMState *rs, bool last_stage)
{
    // 暂时只有 vhost 和 virtio 添加了 notifier，所以可以暂时先不管
    precopy_notify(PRECOPY_NOTIFY_BEFORE_BITMAP_SYNC, &local_err)
    migration_bitmap_sync(rs, bool last_stage);
    precopy_notify(PRECOPY_NOTIFY_AFTER_BITMAP_SYNC, &local_err)
}

static void migration_bitmap_sync(RAMState *rs, bool last_stage)
{
    RAMBlock *block;
    int64_t end_time;

    // dirty bitmap sync 的次数
    stat64_add(&mig_stats.dirty_sync_count, 1);
    // 记录一下上次 dirty bitmap sync 的时间 
    if (!rs->time_last_bitmap_sync)
        rs->time_last_bitmap_sync = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

    //...
    // do global sync for each memory region
    // This is to sync from **KVM** to **ram_list.dirty_memory**
    // ------------------------------ This is the first step ------------------------------
    memory_global_dirty_log_sync(last_stage);

    //...
    // 同步每一个 RAMBlock 的 dirty bitmap
    // 和上面不同，这里是从 **ram_list.dirty_memory** 到 `rb->bmap`。
    // ------------------------------ This is the second step ------------------------------
    RAMBLOCK_FOREACH_NOT_IGNORED(block) {
        ramblock_sync_dirty_bitmap(rs, block);
    }
    stat64_set(&mig_stats.dirty_bytes_last_sync, ram_bytes_remaining());
    //...

    memory_global_after_dirty_log_sync();
    //...

    end_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

    // 两次 sync 的时间间隔差了 1s
    if (end_time > rs->time_last_bitmap_sync + 1000) {
        migration_trigger_throttle(rs);
        // info migrate 会出来的 dirty pages rate 统计数据
        // 就是在这里进行更新的
        migration_update_rates(rs, end_time);
        rs->target_page_count_prev = rs->target_page_count;

        /* reset period counters */
        rs->time_last_bitmap_sync = end_time;
        rs->num_dirty_pages_period = 0;
        rs->bytes_xfer_prev = stat64_get(&mig_stats.transferred);
    }
    if (migrate_events()) {
        uint64_t generation = stat64_get(&mig_stats.dirty_sync_count);
        qapi_event_send_migration_pass(generation);
    }
}

memory_global_dirty_log_sync() / memory_region_sync_dirty_bitmap() / Dirty bitmap from KVM to ram_list->dirty_memory

基于 QEMU 里的 listener 机制。可以看到，从 KVM 往 ram_list->dirty_memory 这里 sync 的这一步，需要决定是用 dirty ring 的方式还是 dirty bitmap 的方式。但是都是两步：

• 要把 KVM 里的 dirty 信息同步到 KVMSlot->dirty_bmap，
• 再把 KVMSlot->dirty_bmap 的信息同步到 ram_list->dirty_memory。

应该优先使用 dirty ring 的方式，再使用 dirty bitmap 的方式，为什么从这里看起来反了？

只不过先判断了 log_sync，但是因为我们在 initialize 的时候并没有给 log_sync 挂上对应的函数，所以其实还是 dirty ring 是被优先考虑的。

void memory_global_dirty_log_sync(bool last_stage)
{
    memory_region_sync_dirty_bitmap(NULL, last_stage);
}

static void memory_region_sync_dirty_bitmap(MemoryRegion *mr, bool last_stage)
{
    //...
    QTAILQ_FOREACH(listener, &memory_listeners, link) {
        // 使用 dirty bitmap 的方式
        if (listener->log_sync) {
            as = listener->address_space;
            view = address_space_get_flatview(as);
            // 对于 memory region 里的每一个 flat range。
            FOR_EACH_FLAT_RANGE(fr, view) {
                if (fr->dirty_log_mask && (!mr || fr->mr == mr)) {
                    MemoryRegionSection mrs = section_from_flat_range(fr, view);
                    listener->log_sync(listener, &mrs);
                }
            }
            //...
        // 使用 dirty ring 的方式
        } else if (listener->log_sync_global) {
            /*
             * No matter whether MR is specified, what we can do here
             * is to do a global sync, because we are not capable to
             * sync in a finer granularity.
             */
            listener->log_sync_global(listener, last_stage);
            //...
        }
    }
}

ramblock_sync_dirty_bitmap() QEMU

很简单的一个函数，这个函数会把 ram_list.dirty_memory 里的内容同步到 rb->bmap。

static void ramblock_sync_dirty_bitmap(RAMState *rs, RAMBlock *rb)
{
    uint64_t new_dirty_pages = cpu_physical_memory_sync_dirty_bitmap(rb, 0, rb->used_length);
    rs->migration_dirty_pages += new_dirty_pages;
    rs->num_dirty_pages_period += new_dirty_pages;
}

cpu_physical_memory_sync_dirty_bitmap() QEMU

执行第二步的关键函数，Sync RAMBlock's dirty bitmap. sync from ram_list.dirty_memory to rb->bmap.

Question 1: Where does ram_list.dirty_memory^ (See DirtyMemoryBlocks) come from? See function memory_global_dirty_log_sync().

ram_save_pending // 最主要的调用点，当然也有其他的调用函数
    migration_bitmap_sync_precopy
        migration_bitmap_sync
            ramblock_sync_dirty_bitmap
                cpu_physical_memory_sync_dirty_bitmap

// length is the number of bytes, NOT the number of pages
// start 表示的是从 rb 开始计数的开始的地方，比如一般都是 0
static inline uint64_t cpu_physical_memory_sync_dirty_bitmap(RAMBlock *rb, ram_addr_t start, ram_addr_t length)
{
    ram_addr_t addr;
    // rb-offset + start 表示的是在整个 ram_list 空间中开始的地址，算上了前面所有 rb 的 size 的和。
    // word 用来计算 src 中的 idx 和 offset，因为 src 是全局的，所以 word 的计算也考虑到了前面的 rb
    unsigned long word = BIT_WORD((start + rb->offset) >> TARGET_PAGE_BITS);
    // 我们在 sync 完了后也要返回到底有多少 dirty 的 page
    uint64_t num_dirty = 0;
    // dest 就是我们要 sync 到的地方
    // dest 是一个列表，index 是 pagenr，value 是是不是 dirty
    unsigned long *dest = rb->bmap;

    /* start address and length is aligned at the start of a word? */
    if (((word * BITS_PER_LONG) << TARGET_PAGE_BITS) == (start + rb->offset) &&
        !(length & ((BITS_PER_LONG << TARGET_PAGE_BITS) - 1))) {
        int k;
        unsigned long * const *src;
        unsigned long idx = (word * BITS_PER_LONG) / DIRTY_MEMORY_BLOCK_SIZE;
        unsigned long offset = BIT_WORD((word * BITS_PER_LONG) % DIRTY_MEMORY_BLOCK_SIZE);
        // The index of the entry where start page fills in
        unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);
        // src is a 2-dimentional arrary, src[i][j] is an unsigned long
        src = qatomic_rcu_read(&ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION])->blocks;

        int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS);
        // nr is not the number of pages, it is the number of entries in bmap
        // (each entry has multiple bits each indicates a page).
        for (k = page; k < page + nr; k++) {
            if (src[idx][offset]) {
                unsigned long bits = qatomic_xchg(&src[idx][offset], 0);
                unsigned long new_dirty;
                new_dirty = ~dest[k];
                dest[k] |= bits;
                new_dirty &= bits;
                num_dirty += ctpopl(new_dirty);
            }

            if (++offset >= BITS_TO_LONGS(DIRTY_MEMORY_BLOCK_SIZE)) {
                offset = 0;
                idx++;
            }
        }

        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);
        }
    } else {
        ram_addr_t offset = rb->offset;

        for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) {
            if (cpu_physical_memory_test_and_clear_dirty(
                        start + addr + offset,
                        TARGET_PAGE_SIZE,
                        DIRTY_MEMORY_MIGRATION)) {
                long k = (start + addr) >> TARGET_PAGE_BITS;
                if (!test_and_set_bit(k, dest)) {
                    num_dirty++;
                }
            }
        }
    }

    return num_dirty;
}

global_dirty_tracking

// 下面这些是可能被置上的 bit
// Dirty tracking enabled because migration is running
#define GLOBAL_DIRTY_MIGRATION  (1U << 0)
// Dirty tracking enabled because measuring dirty rate
// 并不是只有在 migration 的时候才会 measure dirty rate
// 即使不迁移，也可以通过 calc-dirty-rate 来触发的
#define GLOBAL_DIRTY_DIRTY_RATE (1U << 1)
// Dirty tracking enabled because dirty limit
#define GLOBAL_DIRTY_LIMIT      (1U << 2)
#define GLOBAL_DIRTY_MASK  (0x7)

unsigned int global_dirty_tracking;

// 通过 `memory_global_dirty_log_start()` 置上，通过 `memory_global_dirty_log_do_stop()` 清空。
global_dirty_log_change
    memory_global_dirty_log_start
        global_dirty_tracking |= flags;

global_dirty_log_change
    memory_global_dirty_log_stop
        memory_global_dirty_log_do_stop
            global_dirty_tracking &= ~flags;

Dirty memory logging clients / QEMU

一共有这三个 clients。其中我认为比较重要的是 DIRTY_MEMORY_MIGRATION。

#define DIRTY_MEMORY_VGA       0
#define DIRTY_MEMORY_CODE      1  // 这个主要是给 TCG 用的
#define DIRTY_MEMORY_MIGRATION 2
#define DIRTY_MEMORY_NUM       3  /* num of dirty bits */

memory_region_get_dirty_log_mask() QEMU

在 mr->dirty_log_mask 的基础上考虑要不要加一个 bit 上去。

uint8_t memory_region_get_dirty_log_mask(MemoryRegion *mr)
{
    uint8_t mask = mr->dirty_log_mask;
    RAMBlock *rb = mr->ram_block;

    if (global_dirty_tracking && ((rb && qemu_ram_is_migratable(rb)) || memory_region_is_iommu(mr))) {
        // 看来说是 mask，其实只有一个 bit 被 set 了
        mask |= (1 << DIRTY_MEMORY_MIGRATION);
    }

    //...
    return mask;
}

DirtyMemoryBlocks QEMU

The dirty memory bitmap is split into fixed-size blocks to allow growth under RCU. The bitmap for a block can be accessed as follows:

// 给定一个 addr，我们可以这样用来判断这个地址是不是 dirty
rcu_read_lock();
DirtyMemoryBlocks *blocks = qatomic_rcu_read(&ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION]);
ram_addr_t idx = (addr >> TARGET_PAGE_BITS) / DIRTY_MEMORY_BLOCK_SIZE;
unsigned long *block = blocks.blocks[idx];
rcu_read_unlock();

#define DIRTY_MEMORY_BLOCK_SIZE ((ram_addr_t)256 * 1024 * 8)

Organization into blocks allows dirty memory to grow (but not shrink). When adding new RAMBlocks requires the dirty memory to grow, a new DirtyMemoryBlocks array is allocated with pointers to existing blocks kept the same. (RAMBlock 和 DirtyMemoryBlocks 本身并没有对应关系，因为 DirtyMemoryBlocks 表示的是整个 Guest 地址空间，每一个 block 是 fix size 的). 详见 dirty_memory_extend()。

添加一个新的 RAMBlock 的调用流程：

ram_block_add
    if (new_ram_size > old_ram_size)
        dirty_memory_extend(old_ram_size, new_ram_size);
            // 根据新的 ram 大小来调整这个全局的 DirtyMemoryBlocks 的大小
            new_blocks = g_malloc(sizeof(*new_blocks) + sizeof(new_blocks->blocks[0]) * new_num_blocks);
            // 把老的那部分 DirtyMemoryBlocks 直接 copy 过来
            memcpy(new_blocks->blocks, old_blocks->blocks, old_num_blocks * sizeof(old_blocks->blocks[0]));
            // 给每一个新的部分分配 bitmap
            new_blocks->blocks[j] = bitmap_new(DIRTY_MEMORY_BLOCK_SIZE);

typedef struct {
    //...
    // 一个 dirty memory block (简称 block) 表示的是一串 long 所组成的大小为 256 * 1024 * 8bits 的一片内存区域
    // 一般来说对于这个 blocks 成员变量，我们先通过 idx = page / block_size 计算出这个 page 属于哪一个 block
    // 再通过 offset = page % block_size 计算出在那一个 block 内的偏移。
    // 总结一下就是 DirtyMemoryBlocks 中 block 的数量是可以变的，但是每一个 block 的大小是固定的。
    unsigned long *blocks[];
} DirtyMemoryBlocks;

这个也只是一个 QEMU 里对于 dirty bitmap 的缓存，具体的还是需要从 kernel space (KVM) 来同步过来，同步的工作是在 memory_region_sync_dirty_bitmap 一路调用到 kvm_physical_sync_dirty_bitmap。

主要是在这几个函数里被使用的：

// clear 某一个 dirty 位
cpu_physical_memory_test_and_clear_dirty
// 置某一位为 dirty
cpu_physical_memory_set_dirty_flag

cpu_physical_memory_set_dirty_lebitmap

cpu_physical_memory_get_dirty

cpu_physical_memory_set_dirty_range

接下来我们可以看看这几个函数的调用流程：

cpu_physical_memory_set_dirty_flag() QEMU

在 x86 的代码里，这个函数不会被调用，这说明 x86 的架构不需要手动置上 dirty flag。

// addr is GPA
static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, unsigned client)
{
    unsigned long page, idx, offset;
    DirtyMemoryBlocks *blocks;
    //...
    page = addr >> TARGET_PAGE_BITS;
    idx = page / DIRTY_MEMORY_BLOCK_SIZE;
    offset = page % DIRTY_MEMORY_BLOCK_SIZE;
    //...
    blocks = qatomic_rcu_read(&ram_list.dirty_memory[client]);
    set_bit_atomic(offset, blocks->blocks[idx]);
}

cpu_physical_memory_test_and_clear_dirty() QEMU

// 最主要的调用路径，为什么会从这里开始调用呢
cpu_physical_memory_sync_dirty_bitmap
    cpu_physical_memory_test_and_clear_dirty

/* Note: start and end must be within the same ram block.  */
bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, ram_addr_t length, unsigned client)
{
    DirtyMemoryBlocks *blocks;
    unsigned long end, page, start_page;
    bool dirty = false;
    RAMBlock *ramblock;
    uint64_t mr_offset, mr_size;

    //...
    // End page gfn: end page
    // Start page gfn: start page
    end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;
    start_page = start >> TARGET_PAGE_BITS;
    // "page" is used to iterate
    page = start_page;

    //...
    // Read dirty memory blocks according to the client, client can be:
    //    - DIRTY_MEMORY_VGA
    //    - DIRTY_MEMORY_CODE
    //    - DIRTY_MEMORY_MIGRATION
    blocks = qatomic_rcu_read(&ram_list.dirty_memory[client]);
    // Get the ram block according to GPA
    ramblock = qemu_get_ram_block(start);
    //...
    while (page < end) {
        // idx 是第一级的 index，所以要除以一个 block 的 size
        unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE;
        // offset 是第二级的 index，所以要模
        unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE;
        // 大多数情况下一次性 clear 一个 Dirty memory block
        // 当最后剩的不多时，直接 clear 完
        unsigned long num = MIN(end - page, DIRTY_MEMORY_BLOCK_SIZE - offset);
        // clear "num" bits start from "offset"
        dirty |= bitmap_test_and_clear_atomic(blocks->blocks[idx], offset, num);
        page += num;
    }

    // 同样也需要 clear，不太懂
    mr_offset = (ram_addr_t)(start_page << TARGET_PAGE_BITS) - ramblock->offset;
    mr_size = (end - start_page) << TARGET_PAGE_BITS;
    memory_region_clear_dirty_bitmap(ramblock->mr, mr_offset, mr_size);
    //...

    return dirty;
}

cpu_physical_memory_set_dirty_lebitmap() QEMU

这个函数主要的作用就是把刚刚从 KVM 拿来的新鲜的 dirty bitmap 同步到自己的 ram_list.dirty_memory 中去。

// 最主要的调用路径
ram_save_pending
    migration_bitmap_sync_precopy
        migration_bitmap_sync // 最主要的调用点，其他调用点都是为了计算 dirty rate
            memory_global_dirty_log_sync
                memory_region_sync_dirty_bitmap // 重要函数
                    kml->listener.log_sync_global = kvm_log_sync_global;
                    kml->listener.log_sync = kvm_log_sync;
                        kvm_log_sync / kvm_log_sync_global
                            kvm_physical_sync_dirty_bitmap // Sync dirty bitmap from kernel space
                                kvm_slot_sync_dirty_pages
                                    cpu_physical_memory_set_dirty_lebitmap

mark_page_dirty_in_slot() KVM / where to set dirty bitmap in KVM

第一种调用链：从 KVM code 里直接去 write guest 内存里的内容，这种一般是为了实现一些 PV 的 feature，比如 kvmclock, wall_clock 就是用这种方式写的。

kvm_write_guest / kvm_vcpu_write_guest
    kvm_write_guest_page / kvm_vcpu_write_guest_page
        __kvm_write_guest_page
            mark_page_dirty_in_slot

第二种调用链：好像是和 nested MMU 相关的。

page_fault
    walk_addr // gva_to_gpa 也调用了
        walk_addr_generic
            update_accessed_dirty_bits
                kvm_vcpu_mark_page_dirty / mark_page_dirty
                    mark_page_dirty_in_slot

KVM_GET_DIRTY_LOG / Ioctl KVM

// QEMU 调用的流程是这样的：
//     kvm_log_sync
//     kvm_physical_sync_dirty_bitmap()
//     kvm_slot_get_dirty_log(slot) 指明了 slot
//          kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d);
KVM_GET_DIRTY_LOG
    kvm_vm_ioctl_get_dirty_log
        kvm_get_dirty_log_protect
            memslot->dirty_bitmap

kvm_get_dirty_log_protect() KVM

KVM_CLEAR_DIRTY_LOG / Ioctl KVM

This ioctl is mostly useful when KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 is enabled

Overall process of how to use dirty page tracking

在 KVM 中，一个 page 可能处于 4 种状态：

D bit in EPT PTE	Marked as "Dirty" in KVM dirty buffer	Writable	Note
0	0	0	这个 page 被 write block 了，同时从被 write block 到现在这段时间没有被修改过。
0	0	1	（Invalid）这个状态是不可能存在的，因为如果要从 read-only 改为 writable，那么说明我们触发了 page fault 要 unblock 这个 page 并写内容，所以 D bit in PTE 就会被置上
0	1	0	刚刚被调用了 KVM_CLEAR_DIRTY_LOG，这个 ioctl 会 write block 这个 page，会 clear D bit，如果之前这个 page 是 writable 的，那么会把这个 page 在 KVM dirty buffer 里置为 dirty。
0	1	1	（Invalid）这个状态是不可能存在的，原因同上。
1	0	0	（Invalid）这个状态也不应该存在，因为一个被 write block 的页其 D bit 应该不会被置上。
1	0	1	这个页之后被写过了
1	1	0	（Invalid）原因同上。
1	1	1	这个页之后被写过了。

QEMU issue KVM_GET_DIRTY_LOG ioctl to get dirty pages.

QEMU issue KVM_CLEAR_DIRTY_LOG ioctl to clear dirty pages, 如果 clear 完之后

• 如果这个 page 是状态 000，那么什么事都不用做。
• 如果这个 page 是状态 001 或者 011，那么说明这个 page 之前是 writable 的，可能已经被写过了，所以需要在 KVM buffer 里 mark 成 dirty 的并 write-block，也就是变成 010。

可以从下面函数里得到印证：

static bool spte_wrprot_for_clear_dirty(u64 *sptep)
{
	bool was_writable = test_and_clear_bit(PT_WRITABLE_SHIFT, (unsigned long *)sptep);
	if (was_writable && !spte_ad_enabled(*sptep))
		kvm_set_pfn_dirty(spte_to_pfn(*sptep));
	return was_writable;
}

clear_dirty_pt_masked() KVM

static void clear_dirty_pt_masked(struct kvm *kvm, struct kvm_mmu_page *root,
				  gfn_t gfn, unsigned long mask, bool wrprot)
{
	u64 dbit = (wrprot || !kvm_ad_enabled()) ? PT_WRITABLE_MASK : shadow_dirty_mask;
    //...
    // 一个 long 可以表示 64 个 page，对于这 64 个 page 进行迭代
	tdp_root_for_each_leaf_pte(iter, root, gfn + __ffs(mask), gfn + BITS_PER_LONG) {
        //...
        // 没有要 clear 的 page bit 了。
		if (!mask)
			break;

		KVM_MMU_WARN_ON(kvm_ad_enabled() && spte_ad_need_write_protect(iter.old_spte));

		if (iter.level > PG_LEVEL_4K || !(mask & (1UL << (iter.gfn - gfn))))
			continue;

        // mask 里的置为 1 的 bit 表示要 clear 的 page
        // 通过 offset 来找出在 mask 里是否该 page 需要被 clear
        // 如果不需要就 continue。
		if (!(mask & (1UL << (iter.gfn - gfn))))
			continue;

        // clear 掉此 bit，这样下次判断如果 mask 为空就 break
        // 说明所有 bit 都 clear 完了。
		mask &= ~(1UL << (iter.gfn - gfn));

        // 如果 D-bit 没有被置上，那么没什么好做的。
        // 因为说明这个 page 没有变 dirty（换种说法本来就是 write block 的状态，没有变成 writable）
		if (!(iter.old_spte & dbit))
			continue;

        // 重新 block 这个 private page 的 write
		if (is_private_sptep(iter.sptep))
			static_call(kvm_x86_write_block_private_pages)(kvm, (gfn_t *)&iter.gfn, 1);

        // 清除掉 D-bit，不需要 write block 这个 page 因为硬件会在访问时自动置上 dirty bit
        // 如果不支持 A/D bit，那么我们清除的就是 writable bit，从而 write block 这个 page，这是
        // 效率比较低的一种方式。
		iter.old_spte = tdp_mmu_clear_spte_bits(iter.sptep, iter.old_spte, dbit, iter.level);
        //...
        // 因为 D-bit 之前没有的，这说明这个 page 是变 dirty 了的（Writable 的了），所以需要把这个 page
        // 在 KVM 的 dirty buffer 里 mark 成 dirty 的。下一次 GET_LOG 才能获取到。
		kvm_set_pfn_dirty(spte_to_pfn(iter.old_spte));
	}
    //...
}

Dirty rate (QEMU)

只有手动执行计算 dirty rate 的 HMP 命令 calc_dirty_rate 才会触发计算。

hmp_calc_dirty_rate
    qmp_calc_dirty_rate
        qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, (void *)&config, QEMU_THREAD_DETACHED);
            get_dirtyrate_thread
                calculate_dirtyrate

info migrate 也有一行是关于 dirty page rate 的：

migration_bitmap_sync_precopy
    migration_bitmap_sync
        migration_update_rates
            ram_counters.dirty_pages_rate = rs->num_dirty_pages_period * 1000 / (end_time - rs->time_last_bitmap_sync);

Dirty ring and dirty bitmap

有三种模式：

• Dirty ring;
• Dirty bitmap;
• Dirty ring with dirty bitmap（混用：KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP）。

是在哪里进行选择的？看下面代码的逻辑是有 ring 选 ring，无 ring 用 bitmap 的。和我们认知不太一样？

// 我们可以通过 QEMU cmdline 来指定 dirty ring size
object_class_property_add(oc, "dirty-ring-size", "uint32", kvm_get_dirty_ring_size, kvm_set_dirty_ring_size, NULL, NULL);
kvm_init
    // use dirty ring as possible
    kvm_dirty_ring_init
    // fallback
    if (!s->kvm_dirty_ring_size) {
        dirty_log_manual_caps = kvm_check_extension(s, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
        dirty_log_manual_caps &= (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE | KVM_DIRTY_LOG_INITIALLY_SET);
        s->manual_dirty_log_protect = dirty_log_manual_caps;
        if (dirty_log_manual_caps) {
            kvm_vm_enable_cap(s, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2, 0, dirty_log_manual_caps);
        }
    }

Dirty Ring Mode

这是最后一个版本的 KVM patch set：[PATCH v15 00/14] KVM: Dirty ring interface - Peter Xu

Dirty ring mode can provide a finer grained dirty rate measurement in per-vCPU basis. It can only be used when dirty ring is enabled for the specific guest.

Dirty ring is per-vcpu structure that contains an array of PFNs (Page Frame Numbers) of guest memory, it means firstly each vcpu has its own ring structure to keep the dirty pages, meanwhile it's possible that one dirty page can exist in more than one rings. For example, if two vCPUs writes to the same page which used to be clean, then both vcpus will push one PFN of this page to its own dirty ring, the PFN will be reported to userspace (QEMU) as dirty pages. When accounted, the same page can be accounted more than once. But that's not always happening, for example, if the 2nd vcpu writes after the 1st vcpu writes and get the page fault resolved, then only one dirty PFN will be recorded and it'll only be recorded in the 1st vcpu's dirty ring.

Could have an impact on guest workload performance.

Features/DirtyRateCalc - QEMU

添加了一个 KVM capability：KVM_CAP_DIRTY_LOG_RING。

如果只是 Dirty ring mode 的话，之前的 KVM_GET_DIRTY_LOG 和 KVM_CLEAR_DIRTY_LOG 这两个 ioctl 应该都不需要了。取而代之对应功能的是：

• KVM_GET_DIRTY_LOG 替换为：我们直接 access mmap 的 ring buffer 来 reap，不需要 ioctl；
• KVM_CLEAR_DIRTY_LOG 替换为：KVM_RESET_DIRTY_RINGS 来 reenable page write-protection。

关于 ring buffer 大小的设置：The larger the ring buffer, the less likely the ring is full and the VM is forced to exit to userspace. The optimal size depends on the workload, but it is recommended that it be at least 64 KiB (4096 entries). The dirty ring can gets full. When it happens, the KVM_RUN of the vcpu will return with exit reason KVM_EXIT_DIRTY_LOG_FULL.

如何决定要不要 track 一个 kvm_memory_slot？ Just like for dirty page bitmaps, the buffer tracks writes to all user memory regions for which the KVM_MEM_LOG_DIRTY_PAGES flag was set in KVM_SET_USER_MEMORY_REGION.

// 可以看到 flag 上的不同 bit
#define KVM_DIRTY_GFN_F_DIRTY           BIT(0)
#define KVM_DIRTY_GFN_F_RESET           BIT(1)

给 Userspace 定的 collect 的规矩：

• Enabling the capability is only allowed before creating any vCPU（在创建 vCPU 之前才能 enable 这个 feature）
• Userspace accesses the mmaped ring buffer to read the dirty GFNs starting from zero: CPUState->kvm_dirty_gfns.
• An entry in the ring buffer can be unused (flag bits 00), dirty (flag bits 01) or harvested (flag bits 1X).
• If the flags has the DIRTY bit set, then it means this GFN is dirty. The userspace should collect this GFN and mark the flags from state 01b to 1Xb (bit 0 will be ignored by KVM, but bit 1 must be set to show that this GFN is collected and waiting for a reset), and move on to the next GFN.
• The userspace should continue to do this until when the flags of a GFN has the DIRTY bit cleared, it means we've collected all the dirty GFNs we have for now.
• It's not a must that the userspace collects the all dirty GFNs in once.
• However it must collect the dirty GFNs in sequence, i.e., the userspace program cannot skip one dirty GFN to collect the one next to it.
• 综上我们可以发现，第一次读的时候永远是从 gfn 0 开始读，第一个不一定是 dirty 的，但是一旦开始 dirty 了，就会一直遇到 dirty 的，如果下一个 GFN 不再 dirty，那么就说明当前阶段所有的都收割完了。
• After processing one or more entries in the ring buffer, userspace calls the VM ioctl KVM_RESET_DIRTY_RINGS（这个 ioctl 没有参数）to notify the kernel about it, so that the kernel will reprotect those collected GFNs.（他们已经被置上了 reset） Therefore, the ioctl must be called before reading the content of the dirty pages（这句话没有太懂，应该是 writing?）.

和 KVM_GET_DIRTY_LOG 的区别：When reading the dirty ring from userspace it's still possible that the kernel has not yet flushed the hardware dirty buffers（因为本身 kernel 也需要从 hardware 里来读哪些 page dirty 了）into the kernel buffer (the flushing was previously done by the KVM_GET_DIRTY_LOG ioctl). To achieve that, one needs to kick the vcpu out for a hardware buffer flush (vmexit) to make sure all the existing dirty gfns (in the hardware) are flushed to the dirty rings.

kvm_cpu_dirty_log_size() / vmx_cpu_dirty_log_size() KVM

我们给 kvm_x86_ops 加了个新成员变量 int cpu_dirty_log_size（很特殊的待遇，因为其他大多都是成员函数）。

这个大小被初始化为 #define PML_ENTITY_NUM 512。

int kvm_cpu_dirty_log_size(void)
{
	return kvm_x86_ops.cpu_dirty_log_size;
}

struct kvm_x86_ops vt_x86_ops __initdata = {
    //...
	.cpu_dirty_log_size = PML_ENTITY_NUM,
    //...
}

kvm_dirty_ring_check_request() KVM

kvm_arch_vcpu_ioctl_run
    vcpu_run
        vcpu_enter_guest
            kvm_dirty_ring_check_request
bool kvm_dirty_ring_check_request(struct kvm_vcpu *vcpu)
{
	/*
	 * The VCPU isn't runnable when the dirty ring becomes soft full.
	 * The KVM_REQ_DIRTY_RING_SOFT_FULL event is always set to prevent
	 * the VCPU from running until the dirty pages are harvested and
	 * the dirty ring is reset by userspace.
	 */
	if (kvm_check_request(KVM_REQ_DIRTY_RING_SOFT_FULL, vcpu) &&
	    kvm_dirty_ring_soft_full(&vcpu->dirty_ring)) {
		kvm_make_request(KVM_REQ_DIRTY_RING_SOFT_FULL, vcpu);
		vcpu->run->exit_reason = KVM_EXIT_DIRTY_RING_FULL;
		trace_kvm_dirty_ring_exit(vcpu);
		return true;
	}

	return false;
}

struct kvm_dirty_ring KVM

struct kvm_dirty_ring {
	u32 dirty_index;
	u32 reset_index;
	u32 size;
	u32 soft_limit;
	struct kvm_dirty_gfn *dirty_gfns;
	int index;
};

struct kvm_dirty_gfn KVM

以下说的很清楚：

• KVM dirty rings should be mapped at KVM_DIRTY_LOG_PAGE_OFFSET of per-vcpu mmaped regions as an array of struct kvm_dirty_gfn.
• The size of the gfn buffer is decided by the first argument when enabling KVM_CAP_DIRTY_LOG_RING.

// each this struct is a state machine itself
   /*
    * KVM dirty GFN flags, defined as:
    *
    * |---------------+---------------+--------------|
    * | bit 1 (reset) | bit 0 (dirty) | Status       |
    * |---------------+---------------+--------------|
    * |             0 |             0 | Invalid GFN  |
    * |             0 |             1 | Dirty GFN    |
    * |             1 |             X | GFN to reset |
    * |---------------+---------------+--------------|
    *
    * Lifecycle of a dirty GFN goes like:
    *
    *      dirtied         collected        reset
    * 00 -----------> 01 -------------> 1X -------+
    *  ^                                          |
    *  |                                          |
    *  +------------------------------------------+
    *
    * The userspace program is only responsible for the 01->1X state
    * conversion (to collect dirty bits).  Also, it must not skip any
    * dirty bits so that dirty bits are always collected in sequence.
    */
struct kvm_dirty_gfn {
    // The state is embeded in the flags field
	__u32 flags; // 这是一个状态机
	__u32 slot;
	__u64 offset;
};

kvm_dirty_ring_init() QEMU

static int kvm_dirty_ring_init(KVMState *s)
{
    // 用户指定的 dirty ring size
    uint32_t ring_size = s->kvm_dirty_ring_size;
    uint64_t ring_bytes = ring_size * sizeof(struct kvm_dirty_gfn);

    s->kvm_dirty_ring_size = 0;
    s->kvm_dirty_ring_bytes = 0;
    //...

    capability = KVM_CAP_DIRTY_LOG_RING;
    ret = kvm_vm_check_extension(s, capability);
    if (ret <= 0) {
        capability = KVM_CAP_DIRTY_LOG_RING_ACQ_REL;
        ret = kvm_vm_check_extension(s, capability);
        // 两个 CAP 都不支持，那么说明 dirty ring 这个 cap 的确也不支持
        if (ret <= 0)
            return 0;
    }

    // 支持，enable起来。
    ret = kvm_vm_enable_cap(s, capability, 0, ring_bytes);
    // error handling....

    // Enable the backup bitmap if it is supported
    // Use the ring and bitmap combination, see the doc for the reason
    ret = kvm_vm_check_extension(s, KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP);
    // error handling....

    // 这个置上了就表示我们用 dirty ring 了
    s->kvm_dirty_ring_size = ring_size;
    s->kvm_dirty_ring_bytes = ring_bytes;
}

kvm_log_sync_global() QEMU

Dirty ring 的方式，分两步：

• 要把 KVM 里的 dirty 信息同步到 KVMSlot->dirty_bmap，
• 再把 KVMSlot->dirty_bmap 的信息同步到 ram_list->dirty_memory。

static void kvm_log_sync_global(MemoryListener *l, bool last_stage)
{
    KVMMemoryListener *kml = container_of(l, KVMMemoryListener, listener);
    KVMState *s = kvm_state;
    KVMSlot *mem;
    int i;

    // 检查 global_dirty_tracking 的 flags
    if (!memory_global_dirty_cpu())
        return;

    // Flush all kernel dirty addresses into KVMSlot dirty bitmap
    // 这一步，把 KVM 的 dirty 信息同步到了 KVMSlot->dirty_bmap 
    kvm_dirty_ring_flush();

    //...
    // 对于每一个 KVMSlot
    for (i = 0; i < s->nr_slots; i++) {
        mem = &kml->slots[i];
        if (mem->memory_size && (mem->flags & KVM_MEM_LOG_DIRTY_PAGES)) {
            // 这一步，把 KVMSlot->dirty_bmap 同步到  ram_list->dirty_memory 中去
            kvm_slot_sync_dirty_pages(mem);

            // dirty ring 和 bitmap 混用的
            // 再同步一次，因为我们在这里 get了 dirty log 的数据
            if (s->kvm_dirty_ring_with_bitmap && last_stage && kvm_slot_get_dirty_log(s, mem))
                kvm_slot_sync_dirty_pages(mem);

            /*
             * This is not needed by KVM_GET_DIRTY_LOG because the
             * ioctl will unconditionally overwrite the whole region.
             * However kvm dirty ring has no such side effect.
             */
            kvm_slot_reset_dirty_pages(mem);
        }
    }
    //...
}

kvm_dirty_ring_flush() / kvm_dirty_ring_reap() / kvm_dirty_ring_reap_locked() / kvm_dirty_ring_reap_one() QEMU

Reap：收获。所以这个函数是从 KVM mmap 过来的 dirty ring 内存空间收获并处理数据，完了之后再 ioctl 清空 KVM 里的这一段内存区域。

static void kvm_dirty_ring_flush(void)
{
    // locking...
    // First make sure to flush the hardware buffers by kicking all vcpus out in a synchronous way.
    kvm_cpu_synchronize_kick_all();
    kvm_dirty_ring_reap(kvm_state, NULL);
}

static uint64_t kvm_dirty_ring_reap_locked(KVMState *s, CPUState* cpu)
{
    // 指定了 cpu 就 reap 它，没有就 reap 所有
    if (cpu)
        total = kvm_dirty_ring_reap_one(s, cpu);
    else
        CPU_FOREACH(cpu)
            total += kvm_dirty_ring_reap_one(s, cpu);

    // 信息我们都已经 get 到了，清空 KVM 里的 dirty ring
    if (total)
        kvm_vm_ioctl(s, KVM_RESET_DIRTY_RINGS);
    //...
}

static uint32_t kvm_dirty_ring_reap_one(KVMState *s, CPUState *cpu)
{
    // 这是 KVM 共享给 QEMU 的内存，存着每一个 CPU 的 dirty ring 信息
    // 存了许多个 dirty 的 gfn
    struct kvm_dirty_gfn *dirty_gfns = cpu->kvm_dirty_gfns, *cur;
    uint32_t ring_size = s->kvm_dirty_ring_size;
    uint32_t count = 0, fetch = cpu->kvm_fetch_index;

    //...
    if (!cpu->created)
        return 0;

    //...
    while (true) {
        cur = &dirty_gfns[fetch % ring_size];
        // 拿完了
        if (!dirty_gfn_is_dirtied(cur))
            break;
        kvm_dirty_ring_mark_page(s, cur->slot >> 16, cur->slot & 0xffff, cur->offset);
        dirty_gfn_set_collected(cur);
        fetch++;
        count++;
    }
    cpu->kvm_fetch_index = fetch;
    cpu->dirty_pages += count;

    return count;
}

Dirty Bitmap Mode

kvm_log_sync() / kvm_physical_sync_dirty_bitmap() QEMU

Sync dirty bitmap from kernel space，分两步：

• 要把 KVM 里的 dirty 信息同步到 KVMSlot->dirty_bmap，
• 再把 KVMSlot->dirty_bmap 的信息同步到 ram_list->dirty_memory。

static void kvm_log_sync(MemoryListener *listener,
                         MemoryRegionSection *section)
{
    KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
    kvm_slots_lock();
    kvm_physical_sync_dirty_bitmap(kml, section);
    kvm_slots_unlock();
}

/**
 * kvm_physical_sync_dirty_bitmap - Sync dirty bitmap from kernel space
 *
 * This function will first try to fetch dirty bitmap from the kernel,
 * and then updates qemu's dirty bitmap.
 *
 * NOTE: caller must be with kml->slots_lock held.
 *
 * @kml: the KVM memory listener object
 * @section: the memory section to sync the dirty bitmap with
 */
// 我们要 sync 这个 memory region section 的 bitmap
// MemoryRegionSection 和 FlatView 是对应的
static void kvm_physical_sync_dirty_bitmap(KVMMemoryListener *kml, MemoryRegionSection *section)
{
    KVMState *s = kvm_state;
    KVMSlot *mem;
    hwaddr start_addr, size;
    hwaddr slot_size;

    size = kvm_align_section(section, &start_addr);
    while (size) {
        slot_size = MIN(kvm_max_slot_size, size);
        mem = kvm_lookup_matching_slot(kml, start_addr, slot_size);
        //...

        // 通过 ioctl 从 KVM 拿来 dirty bitmap 到 KVMSlot->dirty_bmap 中
        kvm_slot_get_dirty_log(s, mem)
        // 将 KVMSlot->dirty_bmap 同步到 ram_list.dirty_memory 中去
        kvm_slot_sync_dirty_pages(mem);
        start_addr += slot_size;
        size -= slot_size;
    }
}

QEMU register to KVM what to listen for dirty

Non-memory dirty log start

// 只有在开始触发了 live migation 之后才开始进行 dirty page logging
// 没有必要在一开始就打开 dirty page logging
se->ops->save_setup(f, se->opaque);
    ram_save_setup
        ram_init_all(rsp)
            ram_init_bitmaps(*rsp)
                // init to all 1's to first migrate all pages
                ram_list_init_bitmaps();
                // 打开 dirty logging，好像 RAM 并没有对应的函数，只是 vhost vfio 等等的。
                memory_global_dirty_log_start
                // 既然已经全 1 了，为什么还要做一次 sync 呢？
                migration_bitmap_sync_precopy

RAM 对应的 se->opaque 是什么呢？是 global 的 RAMState：

static RAMState *ram_state;
//...
register_savevm_live("ram", 0, 4, &savevm_ram_handlers, &ram_state);

kvm_memory_listener_register
    kml->listener.log_start = kvm_log_start;
    memory_listener_register
        listener_add_address_space
            view = address_space_get_flatview(as);
            FOR_EACH_FLAT_RANGE(fr, view) {
                if (fr->dirty_log_mask && listener->log_start) {
                    listener->log_start(listener, &section, 0, fr->dirty_log_mask);
                }
            }
                kvm_log_start
                    kvm_section_update_flags
                        kvm_slot_update_flags
                            mem->flags = kvm_mem_flags(mr);
                                flags |= KVM_MEM_LOG_DIRTY_PAGES;
                            kvm_set_user_memory_region

KVM handling for dirty page tracking

case KVM_SET_USER_MEMORY_REGION2:
case KVM_SET_USER_MEMORY_REGION: {
    kvm_vm_ioctl_set_memory_region
        kvm_set_memory_region
            __kvm_set_memory_region
                kvm_set_memslot
                    kvm_commit_memory_region
                    	if ((old_flags ^ new_flags) & KVM_MEM_LOG_DIRTY_PAGES) {
                    		int change = (new_flags & KVM_MEM_LOG_DIRTY_PAGES) ? 1 : -1;
                            // 加 nr_memslots_dirty_logging 或者减其数量，根据是不是要 track 新的
                            // 还是要取消 track 新的。
                    		atomic_set(&kvm->nr_memslots_dirty_logging, atomic_read(&kvm->nr_memslots_dirty_logging) + change);
                    	}
                        kvm_arch_commit_memory_region
                            kvm_mmu_slot_apply_flags
                            	bool log_dirty_pages = new_flags & KVM_MEM_LOG_DIRTY_PAGES;
                            	if ((old_flags ^ new_flags) & KVM_MEM_LOG_DIRTY_PAGES)
                            		kvm_mmu_update_cpu_dirty_logging(kvm, log_dirty_pages);
                                        // 会 set 上 VMCS 里的 PML 的 bit
                                		kvm_make_all_cpus_request(kvm, KVM_REQ_UPDATE_CPU_DIRTY_LOGGING);
                        		// Initially-all-set does not require write protecting any page,
                        		// because they're all assumed to be dirty. 如果都是 dirty 的
                        		// 在下次 clear dirty 的时候会被置上 write protect bit 来重新 track
                        		if (kvm_dirty_log_manual_protect_and_init_set(kvm))
                        			return;

// The place to mark the page as dirty
fast_pf_fix_direct_spte
    if (is_writable_pte(new_spte) && !is_writable_pte(old_spte))
        mark_page_dirty_in_slot(vcpu->kvm, fault->slot, gfn);

KVM_REQ_UPDATE_CPU_DIRTY_LOGGING / vt_update_cpu_dirty_logging() KVM

if (kvm_check_request(KVM_REQ_UPDATE_CPU_DIRTY_LOGGING, vcpu))
    static_call(kvm_x86_update_cpu_dirty_logging)(vcpu);
        vt_update_cpu_dirty_logging
void vmx_update_cpu_dirty_logging(struct kvm_vcpu *vcpu)
{	
    struct vcpu_vmx *vmx = to_vmx(vcpu);
    //...
    // nr_memslots_dirty_logging 表示的是 
	if (atomic_read(&vcpu->kvm->nr_memslots_dirty_logging))
		secondary_exec_controls_setbit(vmx, SECONDARY_EXEC_ENABLE_PML);
	else
		secondary_exec_controls_clearbit(vmx, SECONDARY_EXEC_ENABLE_PML);
}

KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2

With this capability enabled, KVM_GET_DIRTY_LOG will not automatically clear and write-protect all pages that are returned as dirty. Rather, userspace will have to do this operation separately using KVM_CLEAR_DIRTY_LOG.

这个 cap 有两个子 cap：

• KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE
• KVM_DIRTY_LOG_INITIALLY_SET

#define KVM_DIRTY_LOG_MANUAL_CAPS   (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE | KVM_DIRTY_LOG_INITIALLY_SET)

kvm_vm_ioctl_enable_cap_generic
    case KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2: {
		u64 allowed_options = KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE;

		if (cap->args[0] & KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE)
			allowed_options = KVM_DIRTY_LOG_MANUAL_CAPS;

		if (cap->flags || (cap->args[0] & ~allowed_options))
			return -EINVAL;
		kvm->manual_dirty_log_protect = cap->args[0];
	}
    
kvm_vm_ioctl_check_extension_generic
    case KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2:
		return KVM_DIRTY_LOG_MANUAL_CAPS;

以下 QEMU 代码可以印证：

memory_region_clear_dirty_bitmap
    kvm_log_clear
        kvm_physical_log_clear
            // 如果我们发现了我们没有置上，就不需要做显式的 clear，因为 get 的时候也会 clear
            if (!s->manual_dirty_log_protect || runstate_check(RUN_STATE_FINISH_MIGRATE)) {
                /* No need to do explicit clear */
                return ret;
            }
            kvm_log_clear_one_slot
                kvm_vm_ioctl(s, KVM_CLEAR_DIRTY_LOG, &d);

以下 KVM 代码用来 get dirty log：

kvm_vm_ioctl
    case KVM_GET_DIRTY_LOG: {
        kvm_vm_ioctl_get_dirty_log
            kvm_get_dirty_log_protect
                if (kvm->manual_dirty_log_protect) {
                else
                    // flush the buffer
                    memset(dirty_bitmap_buffer, 0, n);
                    // Re write-protect the memslot
                    kvm_arch_mmu_enable_log_dirty_pt_masked(kvm, memslot, offset, mask);

3 Code paths can dirty a page without the need that the CPU in non-root mode

• init_rmode_identity_map()
• init_rmode_tss()
• kvmgt_rw_gpa()

init_rmode_identity_map() and init_rmode_tss() will be setup on destination VM no matter what (and the guest cannot even see them).

init_rmode_identity_map() KVM

rmode: real mode.

identity map^

vmx_vcpu_create
    init_rmode_identity_map
static int init_rmode_identity_map(struct kvm *kvm)
{
	struct kvm_vmx *kvm_vmx = to_kvm_vmx(kvm);
	int i, r = 0;
	void __user *uaddr;
	u32 tmp;

    //...
    // 只需要第一个 vcpu 跑过就可以了，全局的就 enable 了
    // 后面的 vcpu 跑到这里的时候就可以直接返回
    // 正是因为有多个 vCPU 会跑到这里，所以才需要一个 mutex（省略了）
	if (likely(kvm_vmx->ept_identity_pagetable_done))
        return;

	if (!kvm_vmx->ept_identity_map_addr)
		kvm_vmx->ept_identity_map_addr = VMX_EPT_IDENTITY_PAGETABLE_ADDR;

    // KVM internal memory slot (not setupted by userspace)
    // 这个 memory region 只有一个 page size 的大小
	uaddr = __x86_set_memory_region(kvm,
					IDENTITY_PAGETABLE_PRIVATE_MEMSLOT,
					kvm_vmx->ept_identity_map_addr,
					PAGE_SIZE);
    // error check...

	/* Set up identity-mapping pagetable for EPT in real mode */
    // 一个 page 里能容纳多少个 32bit PTE，就 copy 多少次
	for (i = 0; i < (PAGE_SIZE / sizeof(tmp)); i++) {
        // realmode 的 PTE 是 32bit？
		tmp = (i << 22) + (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER | _PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_PSE);
        // error checking
        // copy to userspace from &tmp to "uaddr + i * sizeof(tmp)"
		__copy_to_user(uaddr + i * sizeof(tmp), &tmp, sizeof(tmp))
	}
	kvm_vmx->ept_identity_pagetable_done = true;
}