14240dceeSChuan Zheng /* 24240dceeSChuan Zheng * Dirtyrate implement code 34240dceeSChuan Zheng * 44240dceeSChuan Zheng * Copyright (c) 2020 HUAWEI TECHNOLOGIES CO.,LTD. 54240dceeSChuan Zheng * 64240dceeSChuan Zheng * Authors: 74240dceeSChuan Zheng * Chuan Zheng <zhengchuan@huawei.com> 84240dceeSChuan Zheng * 94240dceeSChuan Zheng * This work is licensed under the terms of the GNU GPL, version 2 or later. 104240dceeSChuan Zheng * See the COPYING file in the top-level directory. 114240dceeSChuan Zheng */ 124240dceeSChuan Zheng 134240dceeSChuan Zheng #include "qemu/osdep.h" 14cc37d98bSRichard Henderson #include "qemu/error-report.h" 15662770afSMarc-André Lureau #include <zlib.h> 164240dceeSChuan Zheng #include "qapi/error.h" 174240dceeSChuan Zheng #include "cpu.h" 184240dceeSChuan Zheng #include "exec/ramblock.h" 19826b8bc8SHyman Huang(黄勇) #include "exec/ram_addr.h" 204240dceeSChuan Zheng #include "qemu/rcu_queue.h" 210e21bf24SHyman Huang(黄勇) #include "qemu/main-loop.h" 224240dceeSChuan Zheng #include "qapi/qapi-commands-migration.h" 233ded54b1SChuan Zheng #include "ram.h" 243c0b5dffSChuan Zheng #include "trace.h" 254240dceeSChuan Zheng #include "dirtyrate.h" 26a4a571d9SPeter Xu #include "monitor/hmp.h" 27a4a571d9SPeter Xu #include "monitor/monitor.h" 28a4a571d9SPeter Xu #include "qapi/qmp/qdict.h" 290e21bf24SHyman Huang(黄勇) #include "sysemu/kvm.h" 300e21bf24SHyman Huang(黄勇) #include "sysemu/runstate.h" 310e21bf24SHyman Huang(黄勇) #include "exec/memory.h" 320e21bf24SHyman Huang(黄勇) 334998a37eSHyman Huang(黄勇) /* 344998a37eSHyman Huang(黄勇) * total_dirty_pages is procted by BQL and is used 354998a37eSHyman Huang(黄勇) * to stat dirty pages during the period of two 364998a37eSHyman Huang(黄勇) * memory_global_dirty_log_sync 374998a37eSHyman Huang(黄勇) */ 384998a37eSHyman Huang(黄勇) uint64_t total_dirty_pages; 394998a37eSHyman Huang(黄勇) 400e21bf24SHyman Huang(黄勇) typedef struct DirtyPageRecord { 410e21bf24SHyman Huang(黄勇) uint64_t start_pages; 420e21bf24SHyman Huang(黄勇) uint64_t end_pages; 430e21bf24SHyman Huang(黄勇) } DirtyPageRecord; 444240dceeSChuan Zheng 457df3aa30SChuan Zheng static int CalculatingState = DIRTY_RATE_STATUS_UNSTARTED; 46c9a58d71SChuan Zheng static struct DirtyRateStat DirtyStat; 470e21bf24SHyman Huang(黄勇) static DirtyRateMeasureMode dirtyrate_mode = 480e21bf24SHyman Huang(黄勇) DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING; 497df3aa30SChuan Zheng 508244166dSHyman Huang(黄勇) static int64_t dirty_stat_wait(int64_t msec, int64_t initial_time) 51eca58224SChuan Zheng { 52eca58224SChuan Zheng int64_t current_time; 53eca58224SChuan Zheng 54eca58224SChuan Zheng current_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 55eca58224SChuan Zheng if ((current_time - initial_time) >= msec) { 56eca58224SChuan Zheng msec = current_time - initial_time; 57eca58224SChuan Zheng } else { 58eca58224SChuan Zheng g_usleep((msec + initial_time - current_time) * 1000); 59eca58224SChuan Zheng } 60eca58224SChuan Zheng 61eca58224SChuan Zheng return msec; 62eca58224SChuan Zheng } 63eca58224SChuan Zheng 648244166dSHyman Huang(黄勇) static inline void record_dirtypages(DirtyPageRecord *dirty_pages, 658244166dSHyman Huang(黄勇) CPUState *cpu, bool start) 668244166dSHyman Huang(黄勇) { 678244166dSHyman Huang(黄勇) if (start) { 688244166dSHyman Huang(黄勇) dirty_pages[cpu->cpu_index].start_pages = cpu->dirty_pages; 698244166dSHyman Huang(黄勇) } else { 708244166dSHyman Huang(黄勇) dirty_pages[cpu->cpu_index].end_pages = cpu->dirty_pages; 718244166dSHyman Huang(黄勇) } 728244166dSHyman Huang(黄勇) } 738244166dSHyman Huang(黄勇) 748244166dSHyman Huang(黄勇) static int64_t do_calculate_dirtyrate(DirtyPageRecord dirty_pages, 758244166dSHyman Huang(黄勇) int64_t calc_time_ms) 768244166dSHyman Huang(黄勇) { 778244166dSHyman Huang(黄勇) uint64_t memory_size_MB; 788244166dSHyman Huang(黄勇) uint64_t increased_dirty_pages = 798244166dSHyman Huang(黄勇) dirty_pages.end_pages - dirty_pages.start_pages; 808244166dSHyman Huang(黄勇) 818244166dSHyman Huang(黄勇) memory_size_MB = (increased_dirty_pages * TARGET_PAGE_SIZE) >> 20; 828244166dSHyman Huang(黄勇) 838244166dSHyman Huang(黄勇) return memory_size_MB * 1000 / calc_time_ms; 848244166dSHyman Huang(黄勇) } 858244166dSHyman Huang(黄勇) 868244166dSHyman Huang(黄勇) void global_dirty_log_change(unsigned int flag, bool start) 878244166dSHyman Huang(黄勇) { 888244166dSHyman Huang(黄勇) qemu_mutex_lock_iothread(); 898244166dSHyman Huang(黄勇) if (start) { 908244166dSHyman Huang(黄勇) memory_global_dirty_log_start(flag); 918244166dSHyman Huang(黄勇) } else { 928244166dSHyman Huang(黄勇) memory_global_dirty_log_stop(flag); 938244166dSHyman Huang(黄勇) } 948244166dSHyman Huang(黄勇) qemu_mutex_unlock_iothread(); 958244166dSHyman Huang(黄勇) } 968244166dSHyman Huang(黄勇) 978244166dSHyman Huang(黄勇) /* 988244166dSHyman Huang(黄勇) * global_dirty_log_sync 998244166dSHyman Huang(黄勇) * 1. sync dirty log from kvm 1008244166dSHyman Huang(黄勇) * 2. stop dirty tracking if needed. 1018244166dSHyman Huang(黄勇) */ 1028244166dSHyman Huang(黄勇) static void global_dirty_log_sync(unsigned int flag, bool one_shot) 1038244166dSHyman Huang(黄勇) { 1048244166dSHyman Huang(黄勇) qemu_mutex_lock_iothread(); 1058244166dSHyman Huang(黄勇) memory_global_dirty_log_sync(); 1068244166dSHyman Huang(黄勇) if (one_shot) { 1078244166dSHyman Huang(黄勇) memory_global_dirty_log_stop(flag); 1088244166dSHyman Huang(黄勇) } 1098244166dSHyman Huang(黄勇) qemu_mutex_unlock_iothread(); 1108244166dSHyman Huang(黄勇) } 1118244166dSHyman Huang(黄勇) 1128244166dSHyman Huang(黄勇) static DirtyPageRecord *vcpu_dirty_stat_alloc(VcpuStat *stat) 1138244166dSHyman Huang(黄勇) { 1148244166dSHyman Huang(黄勇) CPUState *cpu; 1158244166dSHyman Huang(黄勇) int nvcpu = 0; 1168244166dSHyman Huang(黄勇) 1178244166dSHyman Huang(黄勇) CPU_FOREACH(cpu) { 1188244166dSHyman Huang(黄勇) nvcpu++; 1198244166dSHyman Huang(黄勇) } 1208244166dSHyman Huang(黄勇) 1218244166dSHyman Huang(黄勇) stat->nvcpu = nvcpu; 122c5e8d518SMarkus Armbruster stat->rates = g_new0(DirtyRateVcpu, nvcpu); 1238244166dSHyman Huang(黄勇) 12466997c42SMarkus Armbruster return g_new0(DirtyPageRecord, nvcpu); 1258244166dSHyman Huang(黄勇) } 1268244166dSHyman Huang(黄勇) 1278244166dSHyman Huang(黄勇) static void vcpu_dirty_stat_collect(VcpuStat *stat, 1288244166dSHyman Huang(黄勇) DirtyPageRecord *records, 1298244166dSHyman Huang(黄勇) bool start) 1308244166dSHyman Huang(黄勇) { 1318244166dSHyman Huang(黄勇) CPUState *cpu; 1328244166dSHyman Huang(黄勇) 1338244166dSHyman Huang(黄勇) CPU_FOREACH(cpu) { 1348244166dSHyman Huang(黄勇) record_dirtypages(records, cpu, start); 1358244166dSHyman Huang(黄勇) } 1368244166dSHyman Huang(黄勇) } 1378244166dSHyman Huang(黄勇) 1388244166dSHyman Huang(黄勇) int64_t vcpu_calculate_dirtyrate(int64_t calc_time_ms, 1398244166dSHyman Huang(黄勇) VcpuStat *stat, 1408244166dSHyman Huang(黄勇) unsigned int flag, 1418244166dSHyman Huang(黄勇) bool one_shot) 1428244166dSHyman Huang(黄勇) { 1438244166dSHyman Huang(黄勇) DirtyPageRecord *records; 1448244166dSHyman Huang(黄勇) int64_t init_time_ms; 1458244166dSHyman Huang(黄勇) int64_t duration; 1468244166dSHyman Huang(黄勇) int64_t dirtyrate; 1478244166dSHyman Huang(黄勇) int i = 0; 1488244166dSHyman Huang(黄勇) unsigned int gen_id; 1498244166dSHyman Huang(黄勇) 1508244166dSHyman Huang(黄勇) retry: 1518244166dSHyman Huang(黄勇) init_time_ms = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 1528244166dSHyman Huang(黄勇) 153*370ed600SJamie Iles WITH_QEMU_LOCK_GUARD(&qemu_cpu_list_lock) { 1548244166dSHyman Huang(黄勇) gen_id = cpu_list_generation_id_get(); 1558244166dSHyman Huang(黄勇) records = vcpu_dirty_stat_alloc(stat); 1568244166dSHyman Huang(黄勇) vcpu_dirty_stat_collect(stat, records, true); 157*370ed600SJamie Iles } 1588244166dSHyman Huang(黄勇) 1598244166dSHyman Huang(黄勇) duration = dirty_stat_wait(calc_time_ms, init_time_ms); 1608244166dSHyman Huang(黄勇) 1618244166dSHyman Huang(黄勇) global_dirty_log_sync(flag, one_shot); 1628244166dSHyman Huang(黄勇) 163*370ed600SJamie Iles WITH_QEMU_LOCK_GUARD(&qemu_cpu_list_lock) { 1648244166dSHyman Huang(黄勇) if (gen_id != cpu_list_generation_id_get()) { 1658244166dSHyman Huang(黄勇) g_free(records); 1668244166dSHyman Huang(黄勇) g_free(stat->rates); 1678244166dSHyman Huang(黄勇) cpu_list_unlock(); 1688244166dSHyman Huang(黄勇) goto retry; 1698244166dSHyman Huang(黄勇) } 1708244166dSHyman Huang(黄勇) vcpu_dirty_stat_collect(stat, records, false); 171*370ed600SJamie Iles } 1728244166dSHyman Huang(黄勇) 1738244166dSHyman Huang(黄勇) for (i = 0; i < stat->nvcpu; i++) { 1748244166dSHyman Huang(黄勇) dirtyrate = do_calculate_dirtyrate(records[i], duration); 1758244166dSHyman Huang(黄勇) 1768244166dSHyman Huang(黄勇) stat->rates[i].id = i; 1778244166dSHyman Huang(黄勇) stat->rates[i].dirty_rate = dirtyrate; 1788244166dSHyman Huang(黄勇) 1798244166dSHyman Huang(黄勇) trace_dirtyrate_do_calculate_vcpu(i, dirtyrate); 1808244166dSHyman Huang(黄勇) } 1818244166dSHyman Huang(黄勇) 1828244166dSHyman Huang(黄勇) g_free(records); 1838244166dSHyman Huang(黄勇) 1848244166dSHyman Huang(黄勇) return duration; 1858244166dSHyman Huang(黄勇) } 1868244166dSHyman Huang(黄勇) 187eca58224SChuan Zheng static bool is_sample_period_valid(int64_t sec) 188eca58224SChuan Zheng { 189eca58224SChuan Zheng if (sec < MIN_FETCH_DIRTYRATE_TIME_SEC || 190eca58224SChuan Zheng sec > MAX_FETCH_DIRTYRATE_TIME_SEC) { 191eca58224SChuan Zheng return false; 192eca58224SChuan Zheng } 193eca58224SChuan Zheng 194eca58224SChuan Zheng return true; 195eca58224SChuan Zheng } 196eca58224SChuan Zheng 1977afa08cdSHyman Huang(黄勇) static bool is_sample_pages_valid(int64_t pages) 1987afa08cdSHyman Huang(黄勇) { 1997afa08cdSHyman Huang(黄勇) return pages >= MIN_SAMPLE_PAGE_COUNT && 2007afa08cdSHyman Huang(黄勇) pages <= MAX_SAMPLE_PAGE_COUNT; 2017afa08cdSHyman Huang(黄勇) } 2027afa08cdSHyman Huang(黄勇) 2037df3aa30SChuan Zheng static int dirtyrate_set_state(int *state, int old_state, int new_state) 2047df3aa30SChuan Zheng { 2057df3aa30SChuan Zheng assert(new_state < DIRTY_RATE_STATUS__MAX); 2063c0b5dffSChuan Zheng trace_dirtyrate_set_state(DirtyRateStatus_str(new_state)); 2077df3aa30SChuan Zheng if (qatomic_cmpxchg(state, old_state, new_state) == old_state) { 2087df3aa30SChuan Zheng return 0; 2097df3aa30SChuan Zheng } else { 2107df3aa30SChuan Zheng return -1; 2117df3aa30SChuan Zheng } 2127df3aa30SChuan Zheng } 2137df3aa30SChuan Zheng 2144c437254SChuan Zheng static struct DirtyRateInfo *query_dirty_rate_info(void) 2154c437254SChuan Zheng { 2160e21bf24SHyman Huang(黄勇) int i; 2174c437254SChuan Zheng int64_t dirty_rate = DirtyStat.dirty_rate; 218b21e2380SMarkus Armbruster struct DirtyRateInfo *info = g_new0(DirtyRateInfo, 1); 2190e21bf24SHyman Huang(黄勇) DirtyRateVcpuList *head = NULL, **tail = &head; 2204c437254SChuan Zheng 2214c437254SChuan Zheng info->status = CalculatingState; 2224c437254SChuan Zheng info->start_time = DirtyStat.start_time; 2234c437254SChuan Zheng info->calc_time = DirtyStat.calc_time; 2247afa08cdSHyman Huang(黄勇) info->sample_pages = DirtyStat.sample_pages; 2250e21bf24SHyman Huang(黄勇) info->mode = dirtyrate_mode; 2260e21bf24SHyman Huang(黄勇) 2270e21bf24SHyman Huang(黄勇) if (qatomic_read(&CalculatingState) == DIRTY_RATE_STATUS_MEASURED) { 2280e21bf24SHyman Huang(黄勇) info->has_dirty_rate = true; 2290e21bf24SHyman Huang(黄勇) info->dirty_rate = dirty_rate; 2300e21bf24SHyman Huang(黄勇) 2310e21bf24SHyman Huang(黄勇) if (dirtyrate_mode == DIRTY_RATE_MEASURE_MODE_DIRTY_RING) { 2320e21bf24SHyman Huang(黄勇) /* 2330e21bf24SHyman Huang(黄勇) * set sample_pages with 0 to indicate page sampling 2340e21bf24SHyman Huang(黄勇) * isn't enabled 2350e21bf24SHyman Huang(黄勇) **/ 2360e21bf24SHyman Huang(黄勇) info->sample_pages = 0; 2370e21bf24SHyman Huang(黄勇) info->has_vcpu_dirty_rate = true; 2380e21bf24SHyman Huang(黄勇) for (i = 0; i < DirtyStat.dirty_ring.nvcpu; i++) { 239b21e2380SMarkus Armbruster DirtyRateVcpu *rate = g_new0(DirtyRateVcpu, 1); 2400e21bf24SHyman Huang(黄勇) rate->id = DirtyStat.dirty_ring.rates[i].id; 2410e21bf24SHyman Huang(黄勇) rate->dirty_rate = DirtyStat.dirty_ring.rates[i].dirty_rate; 2420e21bf24SHyman Huang(黄勇) QAPI_LIST_APPEND(tail, rate); 2430e21bf24SHyman Huang(黄勇) } 2440e21bf24SHyman Huang(黄勇) info->vcpu_dirty_rate = head; 2450e21bf24SHyman Huang(黄勇) } 246826b8bc8SHyman Huang(黄勇) 247826b8bc8SHyman Huang(黄勇) if (dirtyrate_mode == DIRTY_RATE_MEASURE_MODE_DIRTY_BITMAP) { 248826b8bc8SHyman Huang(黄勇) info->sample_pages = 0; 249826b8bc8SHyman Huang(黄勇) } 2500e21bf24SHyman Huang(黄勇) } 2514c437254SChuan Zheng 2523c0b5dffSChuan Zheng trace_query_dirty_rate_info(DirtyRateStatus_str(CalculatingState)); 2533c0b5dffSChuan Zheng 2544c437254SChuan Zheng return info; 2554c437254SChuan Zheng } 2564c437254SChuan Zheng 25771864eadSHyman Huang(黄勇) static void init_dirtyrate_stat(int64_t start_time, 25871864eadSHyman Huang(黄勇) struct DirtyRateConfig config) 259c9a58d71SChuan Zheng { 260c9a58d71SChuan Zheng DirtyStat.dirty_rate = -1; 261aa84b506SChuan Zheng DirtyStat.start_time = start_time; 26271864eadSHyman Huang(黄勇) DirtyStat.calc_time = config.sample_period_seconds; 26371864eadSHyman Huang(黄勇) DirtyStat.sample_pages = config.sample_pages_per_gigabytes; 26471864eadSHyman Huang(黄勇) 26571864eadSHyman Huang(黄勇) switch (config.mode) { 26671864eadSHyman Huang(黄勇) case DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING: 26771864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_dirty_samples = 0; 26871864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_sample_count = 0; 26971864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_block_mem_MB = 0; 27071864eadSHyman Huang(黄勇) break; 27171864eadSHyman Huang(黄勇) case DIRTY_RATE_MEASURE_MODE_DIRTY_RING: 27271864eadSHyman Huang(黄勇) DirtyStat.dirty_ring.nvcpu = -1; 27371864eadSHyman Huang(黄勇) DirtyStat.dirty_ring.rates = NULL; 27471864eadSHyman Huang(黄勇) break; 27571864eadSHyman Huang(黄勇) default: 27671864eadSHyman Huang(黄勇) break; 27771864eadSHyman Huang(黄勇) } 278c9a58d71SChuan Zheng } 279c9a58d71SChuan Zheng 2800e21bf24SHyman Huang(黄勇) static void cleanup_dirtyrate_stat(struct DirtyRateConfig config) 2810e21bf24SHyman Huang(黄勇) { 2820e21bf24SHyman Huang(黄勇) /* last calc-dirty-rate qmp use dirty ring mode */ 2830e21bf24SHyman Huang(黄勇) if (dirtyrate_mode == DIRTY_RATE_MEASURE_MODE_DIRTY_RING) { 2840e21bf24SHyman Huang(黄勇) free(DirtyStat.dirty_ring.rates); 2850e21bf24SHyman Huang(黄勇) DirtyStat.dirty_ring.rates = NULL; 2860e21bf24SHyman Huang(黄勇) } 2870e21bf24SHyman Huang(黄勇) } 2880e21bf24SHyman Huang(黄勇) 289c9a58d71SChuan Zheng static void update_dirtyrate_stat(struct RamblockDirtyInfo *info) 290c9a58d71SChuan Zheng { 29171864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_dirty_samples += info->sample_dirty_count; 29271864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_sample_count += info->sample_pages_count; 293c9a58d71SChuan Zheng /* size of total pages in MB */ 29471864eadSHyman Huang(黄勇) DirtyStat.page_sampling.total_block_mem_MB += (info->ramblock_pages * 295c9a58d71SChuan Zheng TARGET_PAGE_SIZE) >> 20; 296c9a58d71SChuan Zheng } 297c9a58d71SChuan Zheng 298c9a58d71SChuan Zheng static void update_dirtyrate(uint64_t msec) 299c9a58d71SChuan Zheng { 300c9a58d71SChuan Zheng uint64_t dirtyrate; 30171864eadSHyman Huang(黄勇) uint64_t total_dirty_samples = DirtyStat.page_sampling.total_dirty_samples; 30271864eadSHyman Huang(黄勇) uint64_t total_sample_count = DirtyStat.page_sampling.total_sample_count; 30371864eadSHyman Huang(黄勇) uint64_t total_block_mem_MB = DirtyStat.page_sampling.total_block_mem_MB; 304c9a58d71SChuan Zheng 305c9a58d71SChuan Zheng dirtyrate = total_dirty_samples * total_block_mem_MB * 306c9a58d71SChuan Zheng 1000 / (total_sample_count * msec); 307c9a58d71SChuan Zheng 308c9a58d71SChuan Zheng DirtyStat.dirty_rate = dirtyrate; 309c9a58d71SChuan Zheng } 3107df3aa30SChuan Zheng 311ba0e519fSChuan Zheng /* 312ba0e519fSChuan Zheng * get hash result for the sampled memory with length of TARGET_PAGE_SIZE 313ba0e519fSChuan Zheng * in ramblock, which starts from ramblock base address. 314ba0e519fSChuan Zheng */ 315ba0e519fSChuan Zheng static uint32_t get_ramblock_vfn_hash(struct RamblockDirtyInfo *info, 316ba0e519fSChuan Zheng uint64_t vfn) 317ba0e519fSChuan Zheng { 318ba0e519fSChuan Zheng uint32_t crc; 319ba0e519fSChuan Zheng 320ba0e519fSChuan Zheng crc = crc32(0, (info->ramblock_addr + 321ba0e519fSChuan Zheng vfn * TARGET_PAGE_SIZE), TARGET_PAGE_SIZE); 322ba0e519fSChuan Zheng 3233c0b5dffSChuan Zheng trace_get_ramblock_vfn_hash(info->idstr, vfn, crc); 324ba0e519fSChuan Zheng return crc; 325ba0e519fSChuan Zheng } 326ba0e519fSChuan Zheng 327ba0e519fSChuan Zheng static bool save_ramblock_hash(struct RamblockDirtyInfo *info) 328ba0e519fSChuan Zheng { 329ba0e519fSChuan Zheng unsigned int sample_pages_count; 330ba0e519fSChuan Zheng int i; 331ba0e519fSChuan Zheng GRand *rand; 332ba0e519fSChuan Zheng 333ba0e519fSChuan Zheng sample_pages_count = info->sample_pages_count; 334ba0e519fSChuan Zheng 335ba0e519fSChuan Zheng /* ramblock size less than one page, return success to skip this ramblock */ 336ba0e519fSChuan Zheng if (unlikely(info->ramblock_pages == 0 || sample_pages_count == 0)) { 337ba0e519fSChuan Zheng return true; 338ba0e519fSChuan Zheng } 339ba0e519fSChuan Zheng 340ba0e519fSChuan Zheng info->hash_result = g_try_malloc0_n(sample_pages_count, 341ba0e519fSChuan Zheng sizeof(uint32_t)); 342ba0e519fSChuan Zheng if (!info->hash_result) { 343ba0e519fSChuan Zheng return false; 344ba0e519fSChuan Zheng } 345ba0e519fSChuan Zheng 346ba0e519fSChuan Zheng info->sample_page_vfn = g_try_malloc0_n(sample_pages_count, 347ba0e519fSChuan Zheng sizeof(uint64_t)); 348ba0e519fSChuan Zheng if (!info->sample_page_vfn) { 349ba0e519fSChuan Zheng g_free(info->hash_result); 350ba0e519fSChuan Zheng return false; 351ba0e519fSChuan Zheng } 352ba0e519fSChuan Zheng 353ba0e519fSChuan Zheng rand = g_rand_new(); 354ba0e519fSChuan Zheng for (i = 0; i < sample_pages_count; i++) { 355ba0e519fSChuan Zheng info->sample_page_vfn[i] = g_rand_int_range(rand, 0, 356ba0e519fSChuan Zheng info->ramblock_pages - 1); 357ba0e519fSChuan Zheng info->hash_result[i] = get_ramblock_vfn_hash(info, 358ba0e519fSChuan Zheng info->sample_page_vfn[i]); 359ba0e519fSChuan Zheng } 360ba0e519fSChuan Zheng g_rand_free(rand); 361ba0e519fSChuan Zheng 362ba0e519fSChuan Zheng return true; 363ba0e519fSChuan Zheng } 364ba0e519fSChuan Zheng 365ba0e519fSChuan Zheng static void get_ramblock_dirty_info(RAMBlock *block, 366ba0e519fSChuan Zheng struct RamblockDirtyInfo *info, 367ba0e519fSChuan Zheng struct DirtyRateConfig *config) 368ba0e519fSChuan Zheng { 369ba0e519fSChuan Zheng uint64_t sample_pages_per_gigabytes = config->sample_pages_per_gigabytes; 370ba0e519fSChuan Zheng 371ba0e519fSChuan Zheng /* Right shift 30 bits to calc ramblock size in GB */ 372ba0e519fSChuan Zheng info->sample_pages_count = (qemu_ram_get_used_length(block) * 373ba0e519fSChuan Zheng sample_pages_per_gigabytes) >> 30; 374ba0e519fSChuan Zheng /* Right shift TARGET_PAGE_BITS to calc page count */ 375ba0e519fSChuan Zheng info->ramblock_pages = qemu_ram_get_used_length(block) >> 376ba0e519fSChuan Zheng TARGET_PAGE_BITS; 377ba0e519fSChuan Zheng info->ramblock_addr = qemu_ram_get_host_addr(block); 378ba0e519fSChuan Zheng strcpy(info->idstr, qemu_ram_get_idstr(block)); 379ba0e519fSChuan Zheng } 380ba0e519fSChuan Zheng 381cf0bbb49SChuan Zheng static void free_ramblock_dirty_info(struct RamblockDirtyInfo *infos, int count) 382cf0bbb49SChuan Zheng { 383cf0bbb49SChuan Zheng int i; 384cf0bbb49SChuan Zheng 385cf0bbb49SChuan Zheng if (!infos) { 386cf0bbb49SChuan Zheng return; 387cf0bbb49SChuan Zheng } 388cf0bbb49SChuan Zheng 389cf0bbb49SChuan Zheng for (i = 0; i < count; i++) { 390cf0bbb49SChuan Zheng g_free(infos[i].sample_page_vfn); 391cf0bbb49SChuan Zheng g_free(infos[i].hash_result); 392cf0bbb49SChuan Zheng } 393cf0bbb49SChuan Zheng g_free(infos); 394cf0bbb49SChuan Zheng } 395cf0bbb49SChuan Zheng 396f82583cdSChuan Zheng static bool skip_sample_ramblock(RAMBlock *block) 397f82583cdSChuan Zheng { 398f82583cdSChuan Zheng /* 399f82583cdSChuan Zheng * Sample only blocks larger than MIN_RAMBLOCK_SIZE. 400f82583cdSChuan Zheng */ 401f82583cdSChuan Zheng if (qemu_ram_get_used_length(block) < (MIN_RAMBLOCK_SIZE << 10)) { 4023c0b5dffSChuan Zheng trace_skip_sample_ramblock(block->idstr, 4033c0b5dffSChuan Zheng qemu_ram_get_used_length(block)); 404f82583cdSChuan Zheng return true; 405f82583cdSChuan Zheng } 406f82583cdSChuan Zheng 407f82583cdSChuan Zheng return false; 408f82583cdSChuan Zheng } 409f82583cdSChuan Zheng 410ba0e519fSChuan Zheng static bool record_ramblock_hash_info(struct RamblockDirtyInfo **block_dinfo, 411ba0e519fSChuan Zheng struct DirtyRateConfig config, 412ba0e519fSChuan Zheng int *block_count) 413ba0e519fSChuan Zheng { 414ba0e519fSChuan Zheng struct RamblockDirtyInfo *info = NULL; 415ba0e519fSChuan Zheng struct RamblockDirtyInfo *dinfo = NULL; 416ba0e519fSChuan Zheng RAMBlock *block = NULL; 417ba0e519fSChuan Zheng int total_count = 0; 418ba0e519fSChuan Zheng int index = 0; 419ba0e519fSChuan Zheng bool ret = false; 420ba0e519fSChuan Zheng 421ba0e519fSChuan Zheng RAMBLOCK_FOREACH_MIGRATABLE(block) { 422f82583cdSChuan Zheng if (skip_sample_ramblock(block)) { 423f82583cdSChuan Zheng continue; 424f82583cdSChuan Zheng } 425ba0e519fSChuan Zheng total_count++; 426ba0e519fSChuan Zheng } 427ba0e519fSChuan Zheng 428ba0e519fSChuan Zheng dinfo = g_try_malloc0_n(total_count, sizeof(struct RamblockDirtyInfo)); 429ba0e519fSChuan Zheng if (dinfo == NULL) { 430ba0e519fSChuan Zheng goto out; 431ba0e519fSChuan Zheng } 432ba0e519fSChuan Zheng 433ba0e519fSChuan Zheng RAMBLOCK_FOREACH_MIGRATABLE(block) { 434f82583cdSChuan Zheng if (skip_sample_ramblock(block)) { 435f82583cdSChuan Zheng continue; 436f82583cdSChuan Zheng } 437ba0e519fSChuan Zheng if (index >= total_count) { 438ba0e519fSChuan Zheng break; 439ba0e519fSChuan Zheng } 440ba0e519fSChuan Zheng info = &dinfo[index]; 441ba0e519fSChuan Zheng get_ramblock_dirty_info(block, info, &config); 442ba0e519fSChuan Zheng if (!save_ramblock_hash(info)) { 443ba0e519fSChuan Zheng goto out; 444ba0e519fSChuan Zheng } 445ba0e519fSChuan Zheng index++; 446ba0e519fSChuan Zheng } 447ba0e519fSChuan Zheng ret = true; 448ba0e519fSChuan Zheng 449ba0e519fSChuan Zheng out: 450ba0e519fSChuan Zheng *block_count = index; 451ba0e519fSChuan Zheng *block_dinfo = dinfo; 452ba0e519fSChuan Zheng return ret; 453ba0e519fSChuan Zheng } 454ba0e519fSChuan Zheng 4559c04387bSChuan Zheng static void calc_page_dirty_rate(struct RamblockDirtyInfo *info) 4569c04387bSChuan Zheng { 4579c04387bSChuan Zheng uint32_t crc; 4589c04387bSChuan Zheng int i; 4599c04387bSChuan Zheng 4609c04387bSChuan Zheng for (i = 0; i < info->sample_pages_count; i++) { 4619c04387bSChuan Zheng crc = get_ramblock_vfn_hash(info, info->sample_page_vfn[i]); 4629c04387bSChuan Zheng if (crc != info->hash_result[i]) { 4633c0b5dffSChuan Zheng trace_calc_page_dirty_rate(info->idstr, crc, info->hash_result[i]); 4649c04387bSChuan Zheng info->sample_dirty_count++; 4659c04387bSChuan Zheng } 4669c04387bSChuan Zheng } 4679c04387bSChuan Zheng } 4689c04387bSChuan Zheng 4699c04387bSChuan Zheng static struct RamblockDirtyInfo * 4709c04387bSChuan Zheng find_block_matched(RAMBlock *block, int count, 4719c04387bSChuan Zheng struct RamblockDirtyInfo *infos) 4729c04387bSChuan Zheng { 4739c04387bSChuan Zheng int i; 4749c04387bSChuan Zheng 4759c04387bSChuan Zheng for (i = 0; i < count; i++) { 4769c04387bSChuan Zheng if (!strcmp(infos[i].idstr, qemu_ram_get_idstr(block))) { 4779c04387bSChuan Zheng break; 4789c04387bSChuan Zheng } 4799c04387bSChuan Zheng } 4809c04387bSChuan Zheng 4819c04387bSChuan Zheng if (i == count) { 4829c04387bSChuan Zheng return NULL; 4839c04387bSChuan Zheng } 4849c04387bSChuan Zheng 4859c04387bSChuan Zheng if (infos[i].ramblock_addr != qemu_ram_get_host_addr(block) || 4869c04387bSChuan Zheng infos[i].ramblock_pages != 4879c04387bSChuan Zheng (qemu_ram_get_used_length(block) >> TARGET_PAGE_BITS)) { 4883c0b5dffSChuan Zheng trace_find_page_matched(block->idstr); 4899c04387bSChuan Zheng return NULL; 4909c04387bSChuan Zheng } 4919c04387bSChuan Zheng 49266997c42SMarkus Armbruster return &infos[i]; 4939c04387bSChuan Zheng } 4949c04387bSChuan Zheng 4959c04387bSChuan Zheng static bool compare_page_hash_info(struct RamblockDirtyInfo *info, 4969c04387bSChuan Zheng int block_count) 4979c04387bSChuan Zheng { 4989c04387bSChuan Zheng struct RamblockDirtyInfo *block_dinfo = NULL; 4999c04387bSChuan Zheng RAMBlock *block = NULL; 5009c04387bSChuan Zheng 5019c04387bSChuan Zheng RAMBLOCK_FOREACH_MIGRATABLE(block) { 502f82583cdSChuan Zheng if (skip_sample_ramblock(block)) { 503f82583cdSChuan Zheng continue; 504f82583cdSChuan Zheng } 5059c04387bSChuan Zheng block_dinfo = find_block_matched(block, block_count, info); 5069c04387bSChuan Zheng if (block_dinfo == NULL) { 5079c04387bSChuan Zheng continue; 5089c04387bSChuan Zheng } 5099c04387bSChuan Zheng calc_page_dirty_rate(block_dinfo); 5109c04387bSChuan Zheng update_dirtyrate_stat(block_dinfo); 5119c04387bSChuan Zheng } 5129c04387bSChuan Zheng 51371864eadSHyman Huang(黄勇) if (DirtyStat.page_sampling.total_sample_count == 0) { 5149c04387bSChuan Zheng return false; 5159c04387bSChuan Zheng } 5169c04387bSChuan Zheng 5179c04387bSChuan Zheng return true; 5189c04387bSChuan Zheng } 5199c04387bSChuan Zheng 520826b8bc8SHyman Huang(黄勇) static inline void record_dirtypages_bitmap(DirtyPageRecord *dirty_pages, 521826b8bc8SHyman Huang(黄勇) bool start) 522826b8bc8SHyman Huang(黄勇) { 523826b8bc8SHyman Huang(黄勇) if (start) { 524826b8bc8SHyman Huang(黄勇) dirty_pages->start_pages = total_dirty_pages; 525826b8bc8SHyman Huang(黄勇) } else { 526826b8bc8SHyman Huang(黄勇) dirty_pages->end_pages = total_dirty_pages; 527826b8bc8SHyman Huang(黄勇) } 528826b8bc8SHyman Huang(黄勇) } 529826b8bc8SHyman Huang(黄勇) 530826b8bc8SHyman Huang(黄勇) static inline void dirtyrate_manual_reset_protect(void) 531826b8bc8SHyman Huang(黄勇) { 532826b8bc8SHyman Huang(黄勇) RAMBlock *block = NULL; 533826b8bc8SHyman Huang(黄勇) 534826b8bc8SHyman Huang(黄勇) WITH_RCU_READ_LOCK_GUARD() { 535826b8bc8SHyman Huang(黄勇) RAMBLOCK_FOREACH_MIGRATABLE(block) { 536826b8bc8SHyman Huang(黄勇) memory_region_clear_dirty_bitmap(block->mr, 0, 537826b8bc8SHyman Huang(黄勇) block->used_length); 538826b8bc8SHyman Huang(黄勇) } 539826b8bc8SHyman Huang(黄勇) } 540826b8bc8SHyman Huang(黄勇) } 541826b8bc8SHyman Huang(黄勇) 542826b8bc8SHyman Huang(黄勇) static void calculate_dirtyrate_dirty_bitmap(struct DirtyRateConfig config) 543826b8bc8SHyman Huang(黄勇) { 544826b8bc8SHyman Huang(黄勇) int64_t msec = 0; 545826b8bc8SHyman Huang(黄勇) int64_t start_time; 546826b8bc8SHyman Huang(黄勇) DirtyPageRecord dirty_pages; 547826b8bc8SHyman Huang(黄勇) 548826b8bc8SHyman Huang(黄勇) qemu_mutex_lock_iothread(); 549826b8bc8SHyman Huang(黄勇) memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE); 550826b8bc8SHyman Huang(黄勇) 551826b8bc8SHyman Huang(黄勇) /* 552826b8bc8SHyman Huang(黄勇) * 1'round of log sync may return all 1 bits with 553826b8bc8SHyman Huang(黄勇) * KVM_DIRTY_LOG_INITIALLY_SET enable 554826b8bc8SHyman Huang(黄勇) * skip it unconditionally and start dirty tracking 555826b8bc8SHyman Huang(黄勇) * from 2'round of log sync 556826b8bc8SHyman Huang(黄勇) */ 557826b8bc8SHyman Huang(黄勇) memory_global_dirty_log_sync(); 558826b8bc8SHyman Huang(黄勇) 559826b8bc8SHyman Huang(黄勇) /* 560826b8bc8SHyman Huang(黄勇) * reset page protect manually and unconditionally. 561826b8bc8SHyman Huang(黄勇) * this make sure kvm dirty log be cleared if 562826b8bc8SHyman Huang(黄勇) * KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE cap is enabled. 563826b8bc8SHyman Huang(黄勇) */ 564826b8bc8SHyman Huang(黄勇) dirtyrate_manual_reset_protect(); 565826b8bc8SHyman Huang(黄勇) qemu_mutex_unlock_iothread(); 566826b8bc8SHyman Huang(黄勇) 567826b8bc8SHyman Huang(黄勇) record_dirtypages_bitmap(&dirty_pages, true); 568826b8bc8SHyman Huang(黄勇) 569826b8bc8SHyman Huang(黄勇) start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 570826b8bc8SHyman Huang(黄勇) DirtyStat.start_time = start_time / 1000; 571826b8bc8SHyman Huang(黄勇) 572826b8bc8SHyman Huang(黄勇) msec = config.sample_period_seconds * 1000; 5738244166dSHyman Huang(黄勇) msec = dirty_stat_wait(msec, start_time); 574826b8bc8SHyman Huang(黄勇) DirtyStat.calc_time = msec / 1000; 575826b8bc8SHyman Huang(黄勇) 576826b8bc8SHyman Huang(黄勇) /* 5778244166dSHyman Huang(黄勇) * do two things. 578826b8bc8SHyman Huang(黄勇) * 1. fetch dirty bitmap from kvm 579826b8bc8SHyman Huang(黄勇) * 2. stop dirty tracking 580826b8bc8SHyman Huang(黄勇) */ 5818244166dSHyman Huang(黄勇) global_dirty_log_sync(GLOBAL_DIRTY_DIRTY_RATE, true); 582826b8bc8SHyman Huang(黄勇) 583826b8bc8SHyman Huang(黄勇) record_dirtypages_bitmap(&dirty_pages, false); 584826b8bc8SHyman Huang(黄勇) 5858244166dSHyman Huang(黄勇) DirtyStat.dirty_rate = do_calculate_dirtyrate(dirty_pages, msec); 586826b8bc8SHyman Huang(黄勇) } 587826b8bc8SHyman Huang(黄勇) 5880e21bf24SHyman Huang(黄勇) static void calculate_dirtyrate_dirty_ring(struct DirtyRateConfig config) 5890e21bf24SHyman Huang(黄勇) { 5908244166dSHyman Huang(黄勇) int64_t duration; 5910e21bf24SHyman Huang(黄勇) uint64_t dirtyrate = 0; 5920e21bf24SHyman Huang(黄勇) uint64_t dirtyrate_sum = 0; 5930e21bf24SHyman Huang(黄勇) int i = 0; 5940e21bf24SHyman Huang(黄勇) 5958244166dSHyman Huang(黄勇) /* start log sync */ 5968244166dSHyman Huang(黄勇) global_dirty_log_change(GLOBAL_DIRTY_DIRTY_RATE, true); 5970e21bf24SHyman Huang(黄勇) 5988244166dSHyman Huang(黄勇) DirtyStat.start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) / 1000; 5990e21bf24SHyman Huang(黄勇) 6008244166dSHyman Huang(黄勇) /* calculate vcpu dirtyrate */ 6018244166dSHyman Huang(黄勇) duration = vcpu_calculate_dirtyrate(config.sample_period_seconds * 1000, 6028244166dSHyman Huang(黄勇) &DirtyStat.dirty_ring, 6038244166dSHyman Huang(黄勇) GLOBAL_DIRTY_DIRTY_RATE, 6048244166dSHyman Huang(黄勇) true); 6050e21bf24SHyman Huang(黄勇) 6068244166dSHyman Huang(黄勇) DirtyStat.calc_time = duration / 1000; 6070e21bf24SHyman Huang(黄勇) 6088244166dSHyman Huang(黄勇) /* calculate vm dirtyrate */ 6090e21bf24SHyman Huang(黄勇) for (i = 0; i < DirtyStat.dirty_ring.nvcpu; i++) { 6108244166dSHyman Huang(黄勇) dirtyrate = DirtyStat.dirty_ring.rates[i].dirty_rate; 6110e21bf24SHyman Huang(黄勇) DirtyStat.dirty_ring.rates[i].dirty_rate = dirtyrate; 6120e21bf24SHyman Huang(黄勇) dirtyrate_sum += dirtyrate; 6130e21bf24SHyman Huang(黄勇) } 6140e21bf24SHyman Huang(黄勇) 6150e21bf24SHyman Huang(黄勇) DirtyStat.dirty_rate = dirtyrate_sum; 6160e21bf24SHyman Huang(黄勇) } 6170e21bf24SHyman Huang(黄勇) 6180e21bf24SHyman Huang(黄勇) static void calculate_dirtyrate_sample_vm(struct DirtyRateConfig config) 6194240dceeSChuan Zheng { 620cf0bbb49SChuan Zheng struct RamblockDirtyInfo *block_dinfo = NULL; 621cf0bbb49SChuan Zheng int block_count = 0; 622cf0bbb49SChuan Zheng int64_t msec = 0; 623cf0bbb49SChuan Zheng int64_t initial_time; 624cf0bbb49SChuan Zheng 625cf0bbb49SChuan Zheng rcu_read_lock(); 626cf0bbb49SChuan Zheng initial_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME); 627cf0bbb49SChuan Zheng if (!record_ramblock_hash_info(&block_dinfo, config, &block_count)) { 628cf0bbb49SChuan Zheng goto out; 629cf0bbb49SChuan Zheng } 630cf0bbb49SChuan Zheng rcu_read_unlock(); 631cf0bbb49SChuan Zheng 632cf0bbb49SChuan Zheng msec = config.sample_period_seconds * 1000; 6338244166dSHyman Huang(黄勇) msec = dirty_stat_wait(msec, initial_time); 6344c437254SChuan Zheng DirtyStat.start_time = initial_time / 1000; 6354c437254SChuan Zheng DirtyStat.calc_time = msec / 1000; 636cf0bbb49SChuan Zheng 637cf0bbb49SChuan Zheng rcu_read_lock(); 638cf0bbb49SChuan Zheng if (!compare_page_hash_info(block_dinfo, block_count)) { 639cf0bbb49SChuan Zheng goto out; 640cf0bbb49SChuan Zheng } 641cf0bbb49SChuan Zheng 642cf0bbb49SChuan Zheng update_dirtyrate(msec); 643cf0bbb49SChuan Zheng 644cf0bbb49SChuan Zheng out: 645cf0bbb49SChuan Zheng rcu_read_unlock(); 646cf0bbb49SChuan Zheng free_ramblock_dirty_info(block_dinfo, block_count); 6474240dceeSChuan Zheng } 6484240dceeSChuan Zheng 6490e21bf24SHyman Huang(黄勇) static void calculate_dirtyrate(struct DirtyRateConfig config) 6500e21bf24SHyman Huang(黄勇) { 651826b8bc8SHyman Huang(黄勇) if (config.mode == DIRTY_RATE_MEASURE_MODE_DIRTY_BITMAP) { 652826b8bc8SHyman Huang(黄勇) calculate_dirtyrate_dirty_bitmap(config); 653826b8bc8SHyman Huang(黄勇) } else if (config.mode == DIRTY_RATE_MEASURE_MODE_DIRTY_RING) { 6540e21bf24SHyman Huang(黄勇) calculate_dirtyrate_dirty_ring(config); 6550e21bf24SHyman Huang(黄勇) } else { 6560e21bf24SHyman Huang(黄勇) calculate_dirtyrate_sample_vm(config); 6570e21bf24SHyman Huang(黄勇) } 6580e21bf24SHyman Huang(黄勇) 6590e21bf24SHyman Huang(黄勇) trace_dirtyrate_calculate(DirtyStat.dirty_rate); 6600e21bf24SHyman Huang(黄勇) } 6610e21bf24SHyman Huang(黄勇) 6624240dceeSChuan Zheng void *get_dirtyrate_thread(void *arg) 6634240dceeSChuan Zheng { 6644240dceeSChuan Zheng struct DirtyRateConfig config = *(struct DirtyRateConfig *)arg; 6657df3aa30SChuan Zheng int ret; 66615eb2d64SHyman Huang(黄勇) rcu_register_thread(); 6677df3aa30SChuan Zheng 6687df3aa30SChuan Zheng ret = dirtyrate_set_state(&CalculatingState, DIRTY_RATE_STATUS_UNSTARTED, 6697df3aa30SChuan Zheng DIRTY_RATE_STATUS_MEASURING); 6707df3aa30SChuan Zheng if (ret == -1) { 6717df3aa30SChuan Zheng error_report("change dirtyrate state failed."); 6727df3aa30SChuan Zheng return NULL; 6737df3aa30SChuan Zheng } 6744240dceeSChuan Zheng 6754240dceeSChuan Zheng calculate_dirtyrate(config); 6764240dceeSChuan Zheng 6777df3aa30SChuan Zheng ret = dirtyrate_set_state(&CalculatingState, DIRTY_RATE_STATUS_MEASURING, 6787df3aa30SChuan Zheng DIRTY_RATE_STATUS_MEASURED); 6797df3aa30SChuan Zheng if (ret == -1) { 6807df3aa30SChuan Zheng error_report("change dirtyrate state failed."); 6817df3aa30SChuan Zheng } 68215eb2d64SHyman Huang(黄勇) 68315eb2d64SHyman Huang(黄勇) rcu_unregister_thread(); 6844240dceeSChuan Zheng return NULL; 6854240dceeSChuan Zheng } 6864c437254SChuan Zheng 6870e21bf24SHyman Huang(黄勇) void qmp_calc_dirty_rate(int64_t calc_time, 6880e21bf24SHyman Huang(黄勇) bool has_sample_pages, 6890e21bf24SHyman Huang(黄勇) int64_t sample_pages, 6900e21bf24SHyman Huang(黄勇) bool has_mode, 6910e21bf24SHyman Huang(黄勇) DirtyRateMeasureMode mode, 6920e21bf24SHyman Huang(黄勇) Error **errp) 6934c437254SChuan Zheng { 6944c437254SChuan Zheng static struct DirtyRateConfig config; 6954c437254SChuan Zheng QemuThread thread; 6964c437254SChuan Zheng int ret; 6979865d0f6SHyman Huang(黄勇) int64_t start_time; 6984c437254SChuan Zheng 6994c437254SChuan Zheng /* 7004c437254SChuan Zheng * If the dirty rate is already being measured, don't attempt to start. 7014c437254SChuan Zheng */ 7024c437254SChuan Zheng if (qatomic_read(&CalculatingState) == DIRTY_RATE_STATUS_MEASURING) { 7034c437254SChuan Zheng error_setg(errp, "the dirty rate is already being measured."); 7044c437254SChuan Zheng return; 7054c437254SChuan Zheng } 7064c437254SChuan Zheng 7074c437254SChuan Zheng if (!is_sample_period_valid(calc_time)) { 7084c437254SChuan Zheng error_setg(errp, "calc-time is out of range[%d, %d].", 7094c437254SChuan Zheng MIN_FETCH_DIRTYRATE_TIME_SEC, 7104c437254SChuan Zheng MAX_FETCH_DIRTYRATE_TIME_SEC); 7114c437254SChuan Zheng return; 7124c437254SChuan Zheng } 7134c437254SChuan Zheng 7140e21bf24SHyman Huang(黄勇) if (!has_mode) { 7150e21bf24SHyman Huang(黄勇) mode = DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING; 7160e21bf24SHyman Huang(黄勇) } 7170e21bf24SHyman Huang(黄勇) 718bd9510d3SZhenzhong Duan if (has_sample_pages && mode != DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING) { 719bd9510d3SZhenzhong Duan error_setg(errp, "sample-pages is used only in page-sampling mode"); 7200e21bf24SHyman Huang(黄勇) return; 7210e21bf24SHyman Huang(黄勇) } 7220e21bf24SHyman Huang(黄勇) 7237afa08cdSHyman Huang(黄勇) if (has_sample_pages) { 7247afa08cdSHyman Huang(黄勇) if (!is_sample_pages_valid(sample_pages)) { 7257afa08cdSHyman Huang(黄勇) error_setg(errp, "sample-pages is out of range[%d, %d].", 7267afa08cdSHyman Huang(黄勇) MIN_SAMPLE_PAGE_COUNT, 7277afa08cdSHyman Huang(黄勇) MAX_SAMPLE_PAGE_COUNT); 7287afa08cdSHyman Huang(黄勇) return; 7297afa08cdSHyman Huang(黄勇) } 7307afa08cdSHyman Huang(黄勇) } else { 7317afa08cdSHyman Huang(黄勇) sample_pages = DIRTYRATE_DEFAULT_SAMPLE_PAGES; 7327afa08cdSHyman Huang(黄勇) } 7337afa08cdSHyman Huang(黄勇) 7344c437254SChuan Zheng /* 7350e21bf24SHyman Huang(黄勇) * dirty ring mode only works when kvm dirty ring is enabled. 736826b8bc8SHyman Huang(黄勇) * on the contrary, dirty bitmap mode is not. 7370e21bf24SHyman Huang(黄勇) */ 738826b8bc8SHyman Huang(黄勇) if (((mode == DIRTY_RATE_MEASURE_MODE_DIRTY_RING) && 739826b8bc8SHyman Huang(黄勇) !kvm_dirty_ring_enabled()) || 740826b8bc8SHyman Huang(黄勇) ((mode == DIRTY_RATE_MEASURE_MODE_DIRTY_BITMAP) && 741826b8bc8SHyman Huang(黄勇) kvm_dirty_ring_enabled())) { 742826b8bc8SHyman Huang(黄勇) error_setg(errp, "mode %s is not enabled, use other method instead.", 743826b8bc8SHyman Huang(黄勇) DirtyRateMeasureMode_str(mode)); 7440e21bf24SHyman Huang(黄勇) return; 7450e21bf24SHyman Huang(黄勇) } 7460e21bf24SHyman Huang(黄勇) 7470e21bf24SHyman Huang(黄勇) /* 7484c437254SChuan Zheng * Init calculation state as unstarted. 7494c437254SChuan Zheng */ 7504c437254SChuan Zheng ret = dirtyrate_set_state(&CalculatingState, CalculatingState, 7514c437254SChuan Zheng DIRTY_RATE_STATUS_UNSTARTED); 7524c437254SChuan Zheng if (ret == -1) { 7534c437254SChuan Zheng error_setg(errp, "init dirty rate calculation state failed."); 7544c437254SChuan Zheng return; 7554c437254SChuan Zheng } 7564c437254SChuan Zheng 7574c437254SChuan Zheng config.sample_period_seconds = calc_time; 7587afa08cdSHyman Huang(黄勇) config.sample_pages_per_gigabytes = sample_pages; 7590e21bf24SHyman Huang(黄勇) config.mode = mode; 7600e21bf24SHyman Huang(黄勇) 7610e21bf24SHyman Huang(黄勇) cleanup_dirtyrate_stat(config); 7620e21bf24SHyman Huang(黄勇) 7630e21bf24SHyman Huang(黄勇) /* 7640e21bf24SHyman Huang(黄勇) * update dirty rate mode so that we can figure out what mode has 7650e21bf24SHyman Huang(黄勇) * been used in last calculation 7660e21bf24SHyman Huang(黄勇) **/ 7670e21bf24SHyman Huang(黄勇) dirtyrate_mode = mode; 7689865d0f6SHyman Huang(黄勇) 7699865d0f6SHyman Huang(黄勇) start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) / 1000; 7709865d0f6SHyman Huang(黄勇) init_dirtyrate_stat(start_time, config); 7719865d0f6SHyman Huang(黄勇) 7724c437254SChuan Zheng qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, 7734c437254SChuan Zheng (void *)&config, QEMU_THREAD_DETACHED); 7744c437254SChuan Zheng } 7754c437254SChuan Zheng 7764c437254SChuan Zheng struct DirtyRateInfo *qmp_query_dirty_rate(Error **errp) 7774c437254SChuan Zheng { 7784c437254SChuan Zheng return query_dirty_rate_info(); 7794c437254SChuan Zheng } 780a4a571d9SPeter Xu 781a4a571d9SPeter Xu void hmp_info_dirty_rate(Monitor *mon, const QDict *qdict) 782a4a571d9SPeter Xu { 783a4a571d9SPeter Xu DirtyRateInfo *info = query_dirty_rate_info(); 784a4a571d9SPeter Xu 785a4a571d9SPeter Xu monitor_printf(mon, "Status: %s\n", 786a4a571d9SPeter Xu DirtyRateStatus_str(info->status)); 787a4a571d9SPeter Xu monitor_printf(mon, "Start Time: %"PRIi64" (ms)\n", 788a4a571d9SPeter Xu info->start_time); 789bd9510d3SZhenzhong Duan if (info->mode == DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING) { 790a4a571d9SPeter Xu monitor_printf(mon, "Sample Pages: %"PRIu64" (per GB)\n", 791a4a571d9SPeter Xu info->sample_pages); 792bd9510d3SZhenzhong Duan } 793a4a571d9SPeter Xu monitor_printf(mon, "Period: %"PRIi64" (sec)\n", 794a4a571d9SPeter Xu info->calc_time); 7950e21bf24SHyman Huang(黄勇) monitor_printf(mon, "Mode: %s\n", 7960e21bf24SHyman Huang(黄勇) DirtyRateMeasureMode_str(info->mode)); 797a4a571d9SPeter Xu monitor_printf(mon, "Dirty rate: "); 798a4a571d9SPeter Xu if (info->has_dirty_rate) { 799a4a571d9SPeter Xu monitor_printf(mon, "%"PRIi64" (MB/s)\n", info->dirty_rate); 8000e21bf24SHyman Huang(黄勇) if (info->has_vcpu_dirty_rate) { 8010e21bf24SHyman Huang(黄勇) DirtyRateVcpuList *rate, *head = info->vcpu_dirty_rate; 8020e21bf24SHyman Huang(黄勇) for (rate = head; rate != NULL; rate = rate->next) { 8030e21bf24SHyman Huang(黄勇) monitor_printf(mon, "vcpu[%"PRIi64"], Dirty rate: %"PRIi64 8040e21bf24SHyman Huang(黄勇) " (MB/s)\n", rate->value->id, 8050e21bf24SHyman Huang(黄勇) rate->value->dirty_rate); 8060e21bf24SHyman Huang(黄勇) } 8070e21bf24SHyman Huang(黄勇) } 808a4a571d9SPeter Xu } else { 809a4a571d9SPeter Xu monitor_printf(mon, "(not ready)\n"); 810a4a571d9SPeter Xu } 8110e21bf24SHyman Huang(黄勇) 8120e21bf24SHyman Huang(黄勇) qapi_free_DirtyRateVcpuList(info->vcpu_dirty_rate); 813a4a571d9SPeter Xu g_free(info); 814a4a571d9SPeter Xu } 815a4a571d9SPeter Xu 816a4a571d9SPeter Xu void hmp_calc_dirty_rate(Monitor *mon, const QDict *qdict) 817a4a571d9SPeter Xu { 818a4a571d9SPeter Xu int64_t sec = qdict_get_try_int(qdict, "second", 0); 819a4a571d9SPeter Xu int64_t sample_pages = qdict_get_try_int(qdict, "sample_pages_per_GB", -1); 820a4a571d9SPeter Xu bool has_sample_pages = (sample_pages != -1); 8210e21bf24SHyman Huang(黄勇) bool dirty_ring = qdict_get_try_bool(qdict, "dirty_ring", false); 822826b8bc8SHyman Huang(黄勇) bool dirty_bitmap = qdict_get_try_bool(qdict, "dirty_bitmap", false); 823826b8bc8SHyman Huang(黄勇) DirtyRateMeasureMode mode = DIRTY_RATE_MEASURE_MODE_PAGE_SAMPLING; 824a4a571d9SPeter Xu Error *err = NULL; 825a4a571d9SPeter Xu 826a4a571d9SPeter Xu if (!sec) { 827a4a571d9SPeter Xu monitor_printf(mon, "Incorrect period length specified!\n"); 828a4a571d9SPeter Xu return; 829a4a571d9SPeter Xu } 830a4a571d9SPeter Xu 831826b8bc8SHyman Huang(黄勇) if (dirty_ring && dirty_bitmap) { 832826b8bc8SHyman Huang(黄勇) monitor_printf(mon, "Either dirty ring or dirty bitmap " 833826b8bc8SHyman Huang(黄勇) "can be specified!\n"); 834826b8bc8SHyman Huang(黄勇) return; 835826b8bc8SHyman Huang(黄勇) } 836826b8bc8SHyman Huang(黄勇) 837826b8bc8SHyman Huang(黄勇) if (dirty_bitmap) { 838826b8bc8SHyman Huang(黄勇) mode = DIRTY_RATE_MEASURE_MODE_DIRTY_BITMAP; 839826b8bc8SHyman Huang(黄勇) } else if (dirty_ring) { 840826b8bc8SHyman Huang(黄勇) mode = DIRTY_RATE_MEASURE_MODE_DIRTY_RING; 841826b8bc8SHyman Huang(黄勇) } 842826b8bc8SHyman Huang(黄勇) 8430e21bf24SHyman Huang(黄勇) qmp_calc_dirty_rate(sec, has_sample_pages, sample_pages, true, 8440e21bf24SHyman Huang(黄勇) mode, &err); 845a4a571d9SPeter Xu if (err) { 846a4a571d9SPeter Xu hmp_handle_error(mon, err); 847a4a571d9SPeter Xu return; 848a4a571d9SPeter Xu } 849a4a571d9SPeter Xu 850a4a571d9SPeter Xu monitor_printf(mon, "Starting dirty rate measurement with period %"PRIi64 851a4a571d9SPeter Xu " seconds\n", sec); 852a4a571d9SPeter Xu monitor_printf(mon, "[Please use 'info dirty_rate' to check results]\n"); 853a4a571d9SPeter Xu } 854