xref: /qemu/migration/dirtyrate.c (revision 370ed600296982a0248b091915c8e8893508d8a3)
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