qemu-kvm时钟源原理

已于 2023-10-16 17:41:09 修改
阅读量4.4k 收藏 35
点赞数 40
分类专栏： # qemu kvm 文章标签： c语言 linux 运维 服务器
于 2023-06-06 21:01:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tombaby_come/article/details/124427207
版权

目录

一、前言和背景

1、问题背景

2、前言

二、        kernel时钟原理和实现

1、RTC

2、PIT

3、TSC

4、HPET

5、ACPI（PM)

6、Hyper-V（KVM环境的时钟源支持)

7、kvm-clock（KVM环境的时钟源支持）

8、kernel各个时钟的总结

三、qemu-kvm中的时钟源

1、RTC

2、PIT

3、TSC

4、HPET

5、ACPI（PM）

6、Hyper-V

7、kvm-clock

8、qemu-kvm时钟总结

四、虚拟机中的时钟源实践

1、linux（以centos为例）

1）-cpu host时

2）-cpu host,kvm=off时

3）-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer时

4）-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时

5）总结.

2、windows10

3、windows7

五、参考链接

 一、前言和背景

1、问题背景

在使用kvm的过程中，我们发现在win10虚拟机环境中，一旦win10虚拟机被stop后，win10虚拟机时钟时间就会丢失stop的这段时间。然而在对比win7虚拟机时发现，win7虚拟机并不会丢失stop的时间。本文主要探索研究，为什么win10会丢失虚拟机stop后会丢失stop时间的问题。

2、前言

首先，我们要知道大部分PC机中有两个时钟源，分别叫做RTC硬件时钟（实时时钟）和OS(操作系统)时钟(软时钟)。

  • RTC硬件时钟独立于操作系统，它为整个计算机提供一个计时标准，是最原始最底层的时钟数据。硬件时钟其实就是RTC(Real Time Clock，实时时钟)也叫做CMOS时钟，它是PC主机板上的一块芯片，它靠电池供电，即使系统断电，也可以维持日期和时间。
  • OS时钟产生于PC主板上的定时/计数芯片，由操作系统控制这个芯片的工作，OS时钟的基本单位就是该芯片的计数周期。OS时钟是由可编程定时/计数器产生的输出脉冲触发中断而产生的。输出脉冲的周期叫做一个“时钟滴答”。计算机中的时间是以时钟滴答为单位的，每一次时钟滴答，系统时间就会加1。操作系统根据当前时钟滴答的数目就可以得到以秒或毫秒等为单位的其他时间格式。当前linux内核支持的系统时钟的时钟源有PIT计时器/TSC计时器/HPET计时器/ACPI(PM) 计时器，windows还有一个QPC计时器(QPC Timer)。

RTC硬件时钟和OS(操作系统)时钟保持着以下关系：

  • 在开机时操作系统取得RTC硬件时钟中的时间数据来初始化OS时钟，然后通过计数器的向下计数形成了OS时钟。OS时钟只在开机时才有效，而且完全由操作系统控制，所以也被称为软时钟或系统时钟。
  • OS时钟输出脉冲信号，接到中断控制器上，产生中断信号，触发时钟中断，由时钟中断服务程序维持OS时钟的正常工作。
  • RTC硬件时钟是OS时钟的时间基准，操作系统通过读取硬件时钟来初始化OS时钟，在操作系统运行过程中，每隔一个固定时间会刷新或校正RTC硬件时钟中的信息，共同维持着系统时间。

而不同时钟源在linux中是如何实现的，以及qemu-kvm中的时钟源是怎么模拟的，接下来就让我们来探索了解下。

二、kernel时钟原理和实现

以linux x86架构为例， 在第一章节我们说到两种时钟源，即RTC硬件时钟（实时时钟）和OS(操作系统)时钟(软时钟)。RTC在时间相关的硬件中独特的，作用和其他的硬件不同，无论系统是不是运行，RTC时间总是在增加的。而其他的硬件只是Linux操作系统抽象出了的clocksource（时钟源），这些时钟源以一定的频率产生时钟中断，帮助OS完成计时。Linux会在所有的硬件时钟中选择出精度最高作为当前在用的时钟源。它们的结构关系可以通过下图去理解：

当前可用和正在使用的时钟源可以通过以下两个命令分别获取：

接下来，要想探索内核clocksource时钟源，首先我们必须要知道一个最重要的数据结构，就是struct clocksource结构体，如下代码：

  1. /******************include/linux/clocksource.h********************/
  2. /**
  3.  * struct clocksource - hardware abstraction for a free running counter
  4.  *  Provides mostly state-free accessors to the underlying hardware.
  5.  *  This is the structure used for system time.
  6.  *
  7.  * @name:       ptr to clocksource name
  8.  * @list:       list head for registration
  9.  * @rating:     rating value for selection (higher is better)
  10.  *          To avoid rating inflation the following
  11.  *          list should give you a guide as to how
  12.  *          to assign your clocksource a rating
  13.  *          1-99: Unfit for real use
  14.  *              Only available for bootup and testing purposes.
  15.  *          100-199: Base level usability.
  16.  *              Functional for real use, but not desired.
  17.  *          200-299: Good.
  18.  *              A correct and usable clocksource.
  19.  *          300-399: Desired.
  20.  *              A reasonably fast and accurate clocksource.
  21.  *          400-499: Perfect
  22.  *              The ideal clocksource. A must-use where
  23.  *              available.
  24.  * @read:       returns a cycle value, passes clocksource as argument
  25.  * @enable:     optional function to enable the clocksource
  26.  * @disable:        optional function to disable the clocksource
  27.  * @mask:       bitmask for two's complement
  28.  *          subtraction of non 64 bit counters
  29.  * @mult:       cycle to nanosecond multiplier
  30.  * @shift:      cycle to nanosecond divisor (power of two)
  31.  * @max_idle_ns:    max idle time permitted by the clocksource (nsecs)
  32.  * @maxadj:     maximum adjustment value to mult (~11%)
  33.  * @flags:      flags describing special properties
  34.  * @archdata:       arch-specific data
  35.  * @suspend:        suspend function for the clocksource, if necessary
  36.  * @resume:     resume function for the clocksource, if necessary
  37.  * @cycle_last:     most recent cycle counter value seen by ::read()
  38.  * @owner:      module reference, must be set by clocksource in modules
  39.  */
  40. struct clocksource {
  41.     /*
  42.      * Hotpath data, fits in a single cache line when the
  43.      * clocksource itself is cacheline aligned.
  44.      */
  45.     u64 (*read)(struct clocksource *cs);
  46.     u64 cycle_last;
  47.     u64 mask;
  48.     u32 mult;
  49.     u32 shift;
  50.     u64 max_idle_ns;
  51.     u32 maxadj;
  52. #ifdef CONFIG_ARCH_CLOCKSOURCE_DATA
  53.     struct arch_clocksource_data archdata;
  54. #endif
  56.     const char *name;
  57.     struct list_head list;
  58.     int rating;
  59.     int (*enable)(struct clocksource *cs);
  60.     void (*disable)(struct clocksource *cs);
  61.     unsigned long flags;
  62.     void (*suspend)(struct clocksource *cs);
  63.     void (*resume)(struct clocksource *cs);
  65.     /* private: */
  66. #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
  67.     /* Watchdog related data, used by the framework */
  68.     struct list_head wd_list;
  69.     u64 cs_last;
  70.     u64 wd_last;
  71. #endif
  72.     struct module *owner;
  73. } ____cacheline_aligned;

很重要的一个参数是rating时钟源分优劣，精度越高的时钟源的，rating值越大。从注释中我们可以看到：

1--99： 不适合于用作实际的时钟源，只用于启动过程或用于测试；

100--199：基本可用，可用作真实的时钟源，但不推荐；

200--299：精度较好，可用作真实的时钟源；

300--399：很好，精确的时钟源；

400--499：理想的时钟源，如有可能就必须选择它作为时钟源；

接下来，就来看下各个时钟源的原理和实现。

1、RTC

RTC（real time clock）实时时钟和其他的硬件是不同的，RTC吐出来的是时刻，而其他硬件时钟吐出来的是时间。也就是说，RTC能告诉我们，当前是2023年6月5日，14:49:38，但是其他的硬件如TSC，PIT，HPET只能告诉我们，我应该走过了XXX个cycle，按照我的频率，已经过去了多少时间了。

以X86为例，RTC是主板上的一块CMOS芯片，即使系统关机，也可以依赖主板上的电池维持时钟的准确。RTC存储的是UTC时间，而不会考虑timezone。

所以，Linux启动的时候首先会读取RTC来获得当前的时刻值，尽管精度不高（精确到秒）。一般情况下，用户不需要去设置RTC时间，所以本文也不介绍如何去设置RTC时间，感兴趣的可以自行研究。我们大多数情况下只是去读取RTC时间，那么RTC时间是在什么时候，以及如何读取到的呢？接下来让我们来了解下：

首先，Linux内核中有4大time相关的初始化函数：1）init_timers(); 2）hrtimers_init(); 3）timekeeping_init()；4）time_init()。从RTC中读取当前的UTC时间是timekeeping_init中做的事情，调用路径如下：

timekeeping_init

|___________read_persistent_clock    (arch/x86/kernel/rtc.c)

            |_____x86_platform.get_wallclock()

            |_____mach_get_cmos_time  (arch/x86/kernel/x86_init.c)

在struct x86_platform_ops x86_platform结构体中，其get_wallclock成员就是获取cmos RTC时间的接口。

  1. /*****************arch/x86/kernel/x86_init.c ****************/
  2. struct x86_platform_ops x86_platform = {
  3.     .calibrate_cpu          = native_calibrate_cpu,
  4.     .calibrate_tsc          = native_calibrate_tsc,
  5.     .get_wallclock          = mach_get_cmos_time,
  6.     .set_wallclock          = mach_set_rtc_mmss,
  7.     .iommu_shutdown         = iommu_shutdown_noop,
  8.     .is_untracked_pat_range     = is_ISA_range,
  9.     .nmi_init           = default_nmi_init,
  10.     .get_nmi_reason         = default_get_nmi_reason,
  11.     .i8042_detect           = default_i8042_detect,
  12.     .save_sched_clock_state     = tsc_save_sched_clock_state,
  13.     .restore_sched_clock_state  = tsc_restore_sched_clock_state,
  14. };

而mach_get_cmos_time接口的实现如下：

  1. /***************** arch/x86/kernel/rtc.c ****************/
  2. void mach_get_cmos_time(struct timespec *now)
  3. {
  4.     unsigned int status, year, mon, day, hour, min, sec, century = 0;
  5.     unsigned long flags;
  7.     spin_lock_irqsave(&rtc_lock, flags);
  9.     /*
  10.      * If UIP is clear, then we have >= 244 microseconds before
  11.      * RTC registers will be updated.  Spec sheet says that this
  12.      * is the reliable way to read RTC - registers. If UIP is set
  13.      * then the register access might be invalid.
  14.      */
  15.     while ((CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP))
  16.         cpu_relax();
  18.     sec = CMOS_READ(RTC_SECONDS);
  19.     min = CMOS_READ(RTC_MINUTES);
  20.     hour = CMOS_READ(RTC_HOURS);
  21.     day = CMOS_READ(RTC_DAY_OF_MONTH);
  22.     mon = CMOS_READ(RTC_MONTH);
  23.     year = CMOS_READ(RTC_YEAR);
  25. #ifdef CONFIG_ACPI
  26.     if (acpi_gbl_FADT.header.revision >= FADT2_REVISION_ID &&
  27.         acpi_gbl_FADT.century)
  28.         century = CMOS_READ(acpi_gbl_FADT.century);
  29. #endif
  31.     status = CMOS_READ(RTC_CONTROL);
  32.     WARN_ON_ONCE(RTC_ALWAYS_BCD && (status & RTC_DM_BINARY));
  34.     spin_unlock_irqrestore(&rtc_lock, flags);
  36.     if (RTC_ALWAYS_BCD || !(status & RTC_DM_BINARY)) {
  37.         sec = bcd2bin(sec);
  38.         min = bcd2bin(min);
  39.         hour = bcd2bin(hour);
  40.         day = bcd2bin(day);
  41.         mon = bcd2bin(mon);
  42.         year = bcd2bin(year);
  43.     }
  45.     if (century) {
  46.         century = bcd2bin(century);
  47.         year += century * 100;
  48.     } else
  49.         year += CMOS_YEARS_OFFS;
  51.     now->tv_sec = mktime(year, mon, day, hour, min, sec);
  52.     now->tv_nsec = 0;
  53. }

调用mktime，将年月日时分秒组装成1970年1月1日00：00：00这个UNIX基准时间以来的秒数。

2、PIT

Programmalbe Interval Timer(PIT)，PIT主要由8254时钟芯片实现的，这个时钟源是出现比较早，但比较菜的硬件，它的频率只有1MHZ左右，且当前已经被HPET取代。

它的频率在include/linux/timex.h:161:#define PIT_TICK_RATE 1193182ul中设定，也即约1.193182MHZ的频率。在支持HPET时钟源的时候，available_clocksource中是不会出现PIT时钟源的，因为Kernel中发现可以使用HPET，就不会用PIT作为始终源了。后面我们会分析到。

3、TSC

Time Stamp Counter.(TSC)，TSC的主体是位于CPU里面的一个64位的TSC寄存器。每个CPU时钟周期其值加一。比如CPU的主频为1GHZ，则每一秒时间内，TSC寄存器的值将增加1G次，或者说每一个纳秒加一次。x86还提供 rtdsc指令来读取该值，因此TSC也可以作为时钟设备。TSC提供了比RTC更高精度的时间，即纳秒级的时间精度。

TSC这个时钟源的检测和注册是在前文提到的四大初始化中的最后一个：time_init

|_____x86_late_time_init

|___tsc_init

          |________x86_platform.calibrate_tsc (x86_init.c)

                 |______native_calibrate_tsc

                        |___quit_pit_calibrate

而它的rating值为300，如下代码片段：

  1. /******************** arch/x86/kernel/tsc.c*****************************/
  2. static struct clocksource clocksource_tsc = {
  3.     .name                   = "tsc",
  4.     .rating                 = 300,
  5.     .read                   = read_tsc,
  6.     .mask                   = CLOCKSOURCE_MASK(64),
  7.     .flags                  = CLOCK_SOURCE_IS_CONTINUOUS |
  8.                   CLOCK_SOURCE_MUST_VERIFY,
  9. #ifdef CONFIG_X86_64
  10.     .archdata               = { .vclock_mode = VCLOCK_TSC },
  11. #endif
  12. };

4、HPET

HPET(High Precision Event Timer)俗称高精度定时器。PIT 的精度较低，HPET 被设计来替代 PIT 提供高精度时钟中断（至少 10MHz）。它是由微软和 Intel 联合开发的。一个 HPET 包括了一个固定频率的数值增加的计数器以及 3 到 32 个独立的计时器，这每一个计时器有包涵了一个比较器和一个寄存器（保存一个数值，表示触发中断的时机）。每一个比较器都比较计数器中的数值和寄存器的数值，相等就会产生中断。

HPET这个时钟源的检测和注册是在前文提到的四大初始化中的最后一个：time_init

  1. /*********************arch/x86/kernel/time.c********************/
  2. /* Default timer init function */
  3. void __init hpet_time_init(void)
  4. {
  5.     if (!hpet_enable())
  6.         setup_pit_timer();
  7.     setup_default_timer_irq();
  8. }
  10. static __init void x86_late_time_init(void)
  11. {
  12.     x86_init.timers.timer_init();
  13.     tsc_init();
  14. }
  16. /*
  17.  * Initialize TSC and delay the periodic timer init to
  18.  * late x86_late_time_init() so ioremap works.
  19.  */
  20. void __init time_init(void)
  21. {
  22.     late_time_init = x86_late_time_init;
  23. }

time_init的大致流程如下：

time_init

|_________x86_late_time_init

          |_________x86_init.timers.timer_init (arch/x86/kernel/x86_init.c)

                    |________hpet_time_init

                             |_____hpet_enable

                                   |____hpet_clocksource_register

                             |_____set_default_time_irq 

从上面time_init的代码流程中，我们可以看到，当hpet_enable时，是不会再设置pit timer的，因此，一旦系统支持hpet时钟源，则会替代pit时钟源。

而HPET时钟源的rating值是250，其值小于TSC的300。

  1. /*************arch/x86/kernel/hpet.c***********************/
  2. static struct clocksource clocksource_hpet = {
  3.     .name       = "hpet",
  4.     .rating     = 250,
  5.     .read       = read_hpet,
  6.     .mask       = HPET_MASK,
  7.     .flags      = CLOCK_SOURCE_IS_CONTINUOUS,
  8.     .resume     = hpet_resume_counter,
  9. #ifdef CONFIG_X86_64
  10.     .archdata   = { .vclock_mode = VCLOCK_HPET },
  11. #endif
  12. };

5、ACPI（PM）

ACPI Power Management Timer，rating值为200，初始化在fs_initcall时执行，它的rating值为200，低于hept（250）和tsc（300）。

  1. /***************drivers/clocksource/acpi_pm.c******************/
  2. …
  3. static struct clocksource clocksource_acpi_pm = {
  4.     .name       = "acpi_pm",
  5.     .rating     = 200,
  6.     .read       = acpi_pm_read,
  7.     .mask       = (u64)ACPI_PM_MASK,
  8.     .flags      = CLOCK_SOURCE_IS_CONTINUOUS,
  9. };
  10. …
  11. static int __init init_acpi_pm_clocksource(void)
  12. {
  13.     …
  14. }
  15. …
  16. fs_initcall(init_acpi_pm_clocksource);

时钟频率在include/linux/acpi_pmtmr.h:7:#define PMTMR_TICKS_PER_SEC 3579545定义，约为3.5MHZ。

6、Hyper-V（KVM环境的时钟源支持）

Hyper-V 的优点之一是不必担心将虚拟机时钟设置为正确的时间。在绝大多数情况下，虚拟机将它们的时钟同步到主机服务器，这意味着如果Hyper-V主机的时间是正确的，那么虚拟机时钟也是正确的。此外，由于虚拟机将其时钟同步到Hyper-V主机，因此在给定主机上运行的所有虚拟机通常会彼此显示相同的时间。

Hyper-V提供两个时钟源计数器，分别为hyperv_clocksource_msr和hyperv_clocksource_tsc_page，当hyperv_clocksource_tsc_page支持（由内核编译选项CONFIG_HYPERV_TSCPAGE控制，受系统内核编译时配置影响）时，则不再使用hyperv_clocksource_msr时钟源。在启用kvm时，会根据kvm的启动设置，即下方代码的if (ms_hyperv.features & HV_X64_MSR_REFERENCE_TSC_AVAILABLE)语句成立，在检测到虚拟机管理程序后在引导序列的早期调用hyperv_init()初始化，如果配置了hyperv特性以及使能了HYPERV_TSCPAGE则从hyperv_clocksource_tsc_page获取时钟源。当hyperv_clocksource_tsc_page不支持时则从hyperv_clocksource_msr获取时钟源（我们环境不是这样的，不介绍了）。

  1. /****************arch/x86/hyperv/hv_init.c*********************/
  2. /*
  3.  * This function is to be invoked early in the boot sequence after the
  4.  * hypervisor has been detected.
  5.  *
  6.  * 1. Setup the hypercall page.
  7.  * 2. Register Hyper-V specific clocksource.
  8.  */
  9. void hyperv_init(void)
  10. {
  11.     ...
  12. #ifdef CONFIG_HYPERV_TSCPAGE
  13.     if (ms_hyperv.features & HV_X64_MSR_REFERENCE_TSC_AVAILABLE) {
  14.         union hv_x64_msr_hypercall_contents tsc_msr;
  16.         tsc_pg = __vmalloc(PAGE_SIZE, GFP_KERNEL, PAGE_KERNEL);
  17.         if (!tsc_pg)
  18.             goto register_msr_cs;
  20.         hyperv_cs = &hyperv_cs_tsc;
  22.         rdmsrl(HV_X64_MSR_REFERENCE_TSC, tsc_msr.as_uint64);
  24.         tsc_msr.enable = 1;
  25.         tsc_msr.guest_physical_address = vmalloc_to_pfn(tsc_pg);
  27.         wrmsrl(HV_X64_MSR_REFERENCE_TSC, tsc_msr.as_uint64);
  29.         __set_fixmap(HVCLOCK_TSC_PAGE,
  30.                  tsc_msr.guest_physical_address << PAGE_SHIFT,
  31.                  PAGE_KERNEL_VVAR);
  32.         kaiser_add_mapping(__fix_to_virt(HVCLOCK_TSC_PAGE), PAGE_SIZE,
  33.                    __PAGE_KERNEL_VVAR | _PAGE_GLOBAL);
  34.         /* set fixmap before switching vclock mode */
  35.         wmb();
  36.         hyperv_cs_tsc.archdata.vclock_mode = VCLOCK_HVCLOCK;
  38.         clocksource_register_hz(&hyperv_cs_tsc, NSEC_PER_SEC/100);
  39.         return;
  40.     }
  41. register_msr_cs:
  42. #endif
  43.     /*
  44.      * For 32 bit guests just use the MSR based mechanism for reading
  45.      * the partition counter.
  46.      */
  48.     hyperv_cs = &hyperv_cs_msr;
  49.     if (ms_hyperv.features & HV_X64_MSR_TIME_REF_COUNT_AVAILABLE)
  50.         clocksource_register_hz(&hyperv_cs_msr, NSEC_PER_SEC/100);
  52.     return;
  53.     ...
  54. }

Hyper-V时钟源的rating是400，高于tsc（300），hept（250）和acpi_pm（200）。

  1. /*************** arch/x86/hyperv/hv_init.c*******************/
  2. static struct clocksource hyperv_cs_tsc = {
  3.         .name       = "hyperv_clocksource_tsc_page",
  4.         .rating     = 400,
  5.         .read       = read_hv_clock_tsc,
  6.         .mask       = CLOCKSOURCE_MASK(64),
  7.         .flags      = CLOCK_SOURCE_IS_CONTINUOUS,
  8. };
  9. …
  10. static struct clocksource hyperv_cs_msr = {
  11.     .name       = "hyperv_clocksource_msr",
  12.     .rating     = 400,
  13.     .read       = read_hv_clock_msr,
  14.     .mask       = CLOCKSOURCE_MASK(64),
  15.     .flags      = CLOCK_SOURCE_IS_CONTINUOUS,
  16. };

7、kvm-clock（KVM环境的时钟源支持）

kvm-clock是KVM下Linux Guest默认的半虚拟化时钟源。在Guest上实现一个kvmclock驱动，Guest通过该驱动向VMM查询时间。其工作流程也比较简单：Guest分配一个内存页，将该内存地址通过写入MSR告诉VMM，VMM把Host系统时间写入这个内存页，然后Guest去读取这个时间来更新。这里使用到的两个MSR是：MSR_KVM_WALL_CLOCK_NEW和MSR_KVM_SYSTEM_TIME_NEW（这是新的，使用cpuid 0x40000001来标志使用新的还是旧的）分别对应pvclock_wall_clock和pvclock_vcpu_time_info。kvm-clock时钟源会根据kvm的-cpu选项的启动设置（未配置kvm=off时），在检测到虚拟机管理程序后在引导序列的早期调用初始化流程。

kvm-clock的rating是400，高于tsc（300），hept（250）和acpi_pm（200），与Hyper-V的值相等，但是他们同时存在并支持时，会选择kvm-clock。

  1. /****************arch/x86/kernel/kvmclock.c**************/
  2. struct clocksource kvm_clock = {
  3.     .name = "kvm-clock",
  4.     .read = kvm_clock_get_cycles,
  5.     .rating = 400,
  6.     .mask = CLOCKSOURCE_MASK(64),
  7.     .flags = CLOCK_SOURCE_IS_CONTINUOUS,
  8. };
  9. EXPORT_SYSBOL_GPL(kvm_clock);

8、kernel各个时钟的总结

在了解了上面的kernel中不同时钟的原理和相关实现后，我们可以总结对比如下：

Clock

时钟源说明

rating

频率

精度

RTC

CMOS RTC需要电池供电的计时芯片，当操作系统关机后，RTC可以继续计数。系统每次上电以后通过读取rtc时间作为系统的实时时间，否则的话系统默认是将1970年作为起始时间。

特殊的cmos时间

2KHz~8192KHz

1秒或更小

PIT

pit是最古老的pc时钟设备。Intel 8253/8254 PIT是具有3个16位计数器通道的可编程计数/定时器芯片

由HPET替代

1.193182MHZ

约1毫秒

HPET

HPET(High Precision Event Timer)俗称高精度定时器（到时了产生中断），最低时钟频率为10MHZ，而且定义了比较严格的精确度。HPET设计时是为了替代PIT和RTC，但是现在PIT和RTC在一些系统中还是有应用的价值。

250

至少 10MHz

0.1毫秒或更小

TSC

TSC是64bit的cycle计数器，根据CPU的时钟振荡器产生的周期计数。TSC不能产生中断。软件可以通过指令（rdtsc/rdtscp）来获取TSC计数值。

300

CPU主频

1纳秒或更小

ACPI_PM

ACPI timer又称Power management timer（PM timer），是ACPI提供的定时器。它有一个以频率（PIT时钟频率的3倍）向上计数的24位的计数寄存器，但没有计数设置寄存器。每当计数达到最大值时，计数又从0开始递增计数。

200

3.5MHZ

约0.3毫秒

Hyper-V

虚拟机将它们的时钟同步到主机服务器

400

和host的CPU主频同步

1纳秒或更小

kvm-clock

kvm-clock是KVM下Linux Guest默认的半虚拟化时钟源

400

CPU主频

1纳秒或更小

不同时钟的时钟rating不同，精度也受时钟频率影响而有所不同。在推荐使用程度上，也存在着差异。

1）在物理机环境中，可用时钟源推荐顺序为TSC（精度1纳秒或更小）>HPET（精度0.1毫秒或更小）>ACPI_PM（约0.3毫秒）；

2）在虚拟机环境中，比较复杂，但可用时钟源推荐顺序大致为kvm-clock=Hyper-V> TSC（精度1纳秒或更小）>HPET（精度0.1毫秒或更小）>ACPI_PM（约0.3毫秒）。

接下来，我们再来看看在qemu-kvm中，这些时钟源是怎么使用的。

三、qemu-kvm中的时钟源

首先，要想了解qemu-kvm中clocksource，我们需要知道模拟时钟源和kvm可用时钟源的不同。首先，qemu-kvm中模拟了所有主机支持的时钟源的支持，而kvm中可用时钟源理论上和主机是相同的。但是由于中间多了一层虚拟化，所以kvm实际上支持的可用时钟源是受qemu-kvm的启动配置参数影响的，qemu-kvm会在kvm启动配置下配置支持哪些时钟源给kvm虚拟环境。

在第二章节，我们提到过，kvm中实际可以支持的时钟源有：kvm-clock；Hyper-V；TSC；HPET；ACPI_PM。我们也知道可用时钟源推荐顺序为kvm-clock>Hyper-V> TSC（精度1纳秒或更小）>HPET（精度0.1毫秒或更小）>ACPI_PM（约0.3毫秒）。接下来就让我们来看下kvm的时钟源是如何实现的。

  1. struct QEMUTimer {
  2.     int64_t expire_time;        /* in nanoseconds */
  3.     QEMUTimerList *timer_list;
  4.     QEMUTimerCB *cb;
  5.     void *opaque;
  6.     QEMUTimer *next;
  7.     int attributes;
  8.     int scale;
  9. };

的初始化创建流程在hw/i386/kvm/clock.c中实现

Qemu-kvm中所有的时钟读取都需要调用qemu_clock_get_ns接口获取

  1. int64_t qemu_clock_get_ns(QEMUClockType type)
  2. {
  3.     switch (type) {
  4.     case QEMU_CLOCK_REALTIME:
  5.         return get_clock();    //调用clock_gettime()接口
  6.     default:
  7.     case QEMU_CLOCK_VIRTUAL:
  8.         if (use_icount) {
  9.             return cpu_get_icount();
  10.         } else {
  11.             return cpu_get_clock();
  12.         }
  13.     case QEMU_CLOCK_HOST:
  14.         return REPLAY_CLOCK(REPLAY_CLOCK_HOST, get_clock_realtime());
  15.     case QEMU_CLOCK_VIRTUAL_RT:
  16.         return REPLAY_CLOCK(REPLAY_CLOCK_VIRTUAL_RT, cpu_get_clock());
  17.     }
  18. }

kvmclock_create接口

  1. void kvmclock_create(void)
  2. {
  3.     X86CPU *cpu = X86_CPU(first_cpu);
  5.     if (kvm_enabled() &&
  6.         cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) |
  7.                                        (1ULL << KVM_FEATURE_CLOCKSOURCE2))) {
  8.         sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL);
  9.     }
  10. }

1、RTC

qemu-kvm的RTC时钟是通过对0x70端口数据读取来获取当前时钟的，它的实现在hw/rtc/mc146818rtc.c中模拟实现QEMU MC146818 RTC芯片，它的注册流程是：

type_init(mc146818rtc_register_types)

|____mc146818rtc_info

|_____rtc_class_initfn

|_______________DeviceClass *dc = DEVICE_CLASS(klass);

              |_______________dc->realize = rtc_realizefn;

              |_______________dc->reset = rtc_resetdev;

              |_______________dc->vmsd = &vmstate_rtc;

              |_______________dc->props = mc146818rtc_properties;

QEMU MC146818 RTC的频率是为define RTC_CLOCK_RATE            32768，约为32KHZ。

QEMU MC146818 RTC的初始时间设置流程大致如下：

QEMU MC146818 RTC通过读取host时间，并根据qemu-kvm启动时-rtc的相关配置，来设计当前kvm中的RTC的初始时刻。且由于在configure_rtc时，全局变量rtc_clock被设置为QEMU_CLOCK_HOST，因此他始终通过get_clock_realtime（调用gettimeofday并计数当前精确到秒的时刻）读取host时刻。所以，rtc时钟源的时钟时间，不受虚拟机kvm的影响，是独立的，无论qemu-kvm在运行中，还是关机状态，其都是从host读取的时刻。

2、PIT

PIT时钟源的qemu-kvm支持，是通过模拟实现i8254芯片实现的，其主要涉及两个两个时钟源：kvm-pit和isa-pit，分别在hw/i386/kvm/i8254.c和hw/timer/i8254.c文件中实现。

1）hw/i386/kvm/i8254.c

type_init(pit_register_types)    /**** hw/timer/i8254.c****/

|____ type_register_static(&kvm_pit_info);    /**** kvm-pit时钟源***/

|_____ kvm_pit_class_init

2）hw/timer/i8254.c

type_init(pit_register_types)    /**** hw/timer/i8254.c****/

|____ type_register_static(&pit_info);    /**** isa-pit时钟源***/

|_____ pit_class_initfn

它们的频率为define PIT_FREQ 1193182，模拟的频率约为1.19MHZ。

3、TSC

Qemu中没有做特殊的模拟，因为TSC的主体是位于CPU里面的一个64位的TSC寄存器。每个CPU时钟周期其值加一。比如CPU的主频为1GHZ，则每一秒时间内，TSC寄存器的值将增加1G次，或者说每一个纳秒加一次。当需要读取tsc时钟源时间时，只需要去读取tsc寄存器中的计数值+RTC时刻即可获得当前的时间。

4、HPET

HPET时钟源的qemu-kvm支持，是在hw/timer/hpet.c中编写实现的。

type_init(hpet_register_types)    /**** hw/timer/hpet.c****/

|____ type_register_static(&hpet_device_info);    /**** hpet时钟源***/

|_____ hpet_device_class_init

它通过一个struct HPETState结构体，其中存储着模拟的hpet时钟源的计数时间。它的数据是通过一个全局结构体HPETState保持的，并按照一定的频率对数据进行更新，当需要读取的时候，再读出当前计数值，计算当前系统经过的时间。

  1. typedef struct HPETState {
  2.     /*< private >*/
  3.     SysBusDevice parent_obj;
  4.     /*< public >*/
  6.     MemoryRegion iomem;
  7.     uint64_t hpet_offset;
  8.     bool hpet_offset_saved;
  9.     qemu_irq irqs[HPET_NUM_IRQ_ROUTES];
  10.     uint32_t flags;
  11.     uint8_t rtc_irq_level;
  12.     qemu_irq pit_enabled;
  13.     uint8_t num_timers;
  14.     uint32_t intcap;
  15.     HPETTimer timer[HPET_MAX_TIMERS];
  17.     /* Memory-mapped, software visible registers */
  18.     uint64_t capability;        /* capabilities */
  19.     uint64_t config;            /* configuration */
  20.     uint64_t isr;               /* interrupt status reg */
  21.     uint64_t hpet_counter;      /* main counter */
  22.     uint8_t  hpet_id;           /* instance id */
  23. } HPETState;

5、ACPI（PM）

acpi时钟源的qemu-kvm支持，是通过在hw/acpi/core.c中的代码实现的，它的init过程如下。

type_init(piix4_pm_register_types)    /**** hw/timer/hpet.c****/

|____ type_register_static(&piix4_pm_info);

|______piix4_pm_class_init

|_____ piix4_pm_realize

       |_______ acpi_pm_tmr_init    //初始化一个acpi-tmr的io事件

       |_______ acpi_pm1_evt_init   //初始化一个acpi-evt的io事件

       |_______ acpi_pm1_cnt_init   //初始化一个acpi-cnt的io事件

可以看出，acpi_pm时钟源读写的是acpi总线上的一个寄存器，它的时间数据获取是通过以下代码获取的：

muldiv64(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL), PM_TIMER_FREQUENCY, NANOSECONDS_PER_SECOND);

这句代码解析后其实就是以下代码：

/********* include/qemu/timer.h************/

#define NANOSECONDS_PER_SECOND 1000000000LL

/**********include/hw/acpi/acpi.h***********/

#define PM_TIMER_FREQUENCY  3579545

/********** cpus.c ****************/

static int64_t cpu_get_clock_locked(void)

{

    int64_t time;

    time = timers_state.cpu_clock_offset;

    if (timers_state.cpu_ticks_enabled) {

        time += get_clock();

    }

return time;

}

也就是说，按照PM_TIMER_FREQUENCY设置的频率进行计算，当需要读写数据时cpu也必须在计数，不能停止，一旦停止，则acpi的时间无法写入和读出新的时间。而它读取的时间值计算方法为：

时间=acpi-tmr寄存器计数值* PM_TIMER_FREQUENCY+ get_clock()时间。

而它的频率为#define PM_TIMER_FREQUENCY  3579545，约为3.57MHZ。

6、Hyper-V

Hyper-V在qemu中实际需要通过启动qemu-kvm进程时配置获得，它其实就是设计读取0x40000021或者0x40000020寄存器地址的计数时间来作为时钟数据的。先看如下代码：

  1. /*********************target/i386/kvm.c**************************/
  2. static struct {
  3.     const char *desc;
  4.     struct {
  5.         uint32_t fw;
  6.         uint32_t bits;
  7.     } flags[2];
  8.     uint64_t dependencies;
  9. } kvm_hyperv_properties[] = {
  10.     [HYPERV_FEAT_RELAXED] = {
  11.         .desc = "relaxed timing (hv-relaxed)",
  12.         .flags = {
  13.             {.fw = FEAT_HYPERV_EAX,
  14.              .bits = HV_HYPERCALL_AVAILABLE},
  15.             {.fw = FEAT_HV_RECOMM_EAX,
  16.              .bits = HV_RELAXED_TIMING_RECOMMENDED}
  17.         }
  18.     },
  19.     [HYPERV_FEAT_VAPIC] = {
  20.         .desc = "virtual APIC (hv-vapic)",
  21.         .flags = {
  22.             {.fw = FEAT_HYPERV_EAX,
  23.              .bits = HV_HYPERCALL_AVAILABLE | HV_APIC_ACCESS_AVAILABLE},
  24.             {.fw = FEAT_HV_RECOMM_EAX,
  25.              .bits = HV_APIC_ACCESS_RECOMMENDED}
  26.         }
  27.     },
  28.     [HYPERV_FEAT_TIME] = {
  29.         .desc = "clocksources (hv-time)",
  30.         .flags = {
  31.             {.fw = FEAT_HYPERV_EAX,
  32.              .bits = HV_HYPERCALL_AVAILABLE | HV_TIME_REF_COUNT_AVAILABLE |
  33.              HV_REFERENCE_TSC_AVAILABLE}
  34.         }
  35.     },
  36.     ...
  37. }

一旦我们在启动qemu-kvm时配置了hv_time选项，那么此时就使能了HV_X64_MSR_REFERENCE_TSC。参考如下代码：

  1. /****************target/i386/kvm.c****************************/
  2. static int kvm_get_msrs(X86CPU *cpu)
  3. {
  4. ...
  5.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_ASYNC_PF)) {
  6.         kvm_msr_entry_add(cpu, MSR_KVM_ASYNC_PF_EN, 0);
  7.     }
  8.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_PV_EOI)) {
  9.         kvm_msr_entry_add(cpu, MSR_KVM_PV_EOI_EN, 0);
  10.     }
  11.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_STEAL_TIME)) {
  12.         kvm_msr_entry_add(cpu, MSR_KVM_STEAL_TIME, 0);
  13.     }
  14.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_POLL_CONTROL)) {
  15.         kvm_msr_entry_add(cpu, MSR_KVM_POLL_CONTROL, 1);
  16.     }
  17. ...
  18.     if (has_msr_hv_hypercall) {
  19.         kvm_msr_entry_add(cpu, HV_X64_MSR_HYPERCALL, 0);
  20.         kvm_msr_entry_add(cpu, HV_X64_MSR_GUEST_OS_ID, 0);
  21.     }
  22.     if (hyperv_feat_enabled(cpu, HYPERV_FEAT_VAPIC)) {
  23.         kvm_msr_entry_add(cpu, HV_X64_MSR_APIC_ASSIST_PAGE, 0);
  24.     }
  25.     if (hyperv_feat_enabled(cpu, HYPERV_FEAT_TIME)) {
  26.         kvm_msr_entry_add(cpu, HV_X64_MSR_REFERENCE_TSC, 0);
  27.     }
  28. ...
  29. ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, cpu->kvm_msr_buf);
  30.     if (ret < 0) {
  31.         return ret;
  32.     }
  33. ...
  34.     for (i = 0; i < ret; i++) {
  35.         uint32_t index = msrs[i].index;
  36.         switch (index) {
  37.       ...
  38.         case HV_X64_MSR_REFERENCE_TSC:
  39.             env->msr_hv_tsc = msrs[i].data;
  40.       ...
  41.       }
  42. }
  43. ...
  44. }
  47. static int kvm_put_msrs(X86CPU *cpu, int level)
  48. {
  49. ...
  50.     if (level >= KVM_PUT_RESET_STATE) {
  51.         kvm_msr_entry_add(cpu, MSR_IA32_TSC, env->tsc);
  52.         kvm_msr_entry_add(cpu, MSR_KVM_SYSTEM_TIME, env->system_time_msr);
  53.         kvm_msr_entry_add(cpu, MSR_KVM_WALL_CLOCK, env->wall_clock_msr);
  54.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_ASYNC_PF)) {
  55.             kvm_msr_entry_add(cpu, MSR_KVM_ASYNC_PF_EN, env->async_pf_en_msr);
  56.         }
  57.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_PV_EOI)) {
  58.             kvm_msr_entry_add(cpu, MSR_KVM_PV_EOI_EN, env->pv_eoi_en_msr);
  59.         }
  60.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_STEAL_TIME)) {
  61.             kvm_msr_entry_add(cpu, MSR_KVM_STEAL_TIME, env->steal_time_msr);
  62.         }
  64.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_POLL_CONTROL)) {
  65.             kvm_msr_entry_add(cpu, MSR_KVM_POLL_CONTROL, env->poll_control_msr);
  66.         }
  67.       ...
  68.         /*
  69.          * Hyper-V partition-wide MSRs: to avoid clearing them on cpu hot-add,
  70.          * only sync them to KVM on the first cpu
  71.          */
  72.         if (current_cpu == first_cpu) {
  73.             if (has_msr_hv_hypercall) {
  74.                 kvm_msr_entry_add(cpu, HV_X64_MSR_GUEST_OS_ID,
  75.                                   env->msr_hv_guest_os_id);
  76.                 kvm_msr_entry_add(cpu, HV_X64_MSR_HYPERCALL,
  77.                                   env->msr_hv_hypercall);
  78.             }
  79.             if (hyperv_feat_enabled(cpu, HYPERV_FEAT_TIME)) {
  80.                 kvm_msr_entry_add(cpu, HV_X64_MSR_REFERENCE_TSC,
  81.                                   env->msr_hv_tsc);
  82.             }
  83.             if (hyperv_feat_enabled(cpu, HYPERV_FEAT_REENLIGHTENMENT)) {
  84.                 kvm_msr_entry_add(cpu, HV_X64_MSR_REENLIGHTENMENT_CONTROL,
  85.                                   env->msr_hv_reenlightenment_control);
  86.                 kvm_msr_entry_add(cpu, HV_X64_MSR_TSC_EMULATION_CONTROL,
  87.                                   env->msr_hv_tsc_emulation_control);
  88.                 kvm_msr_entry_add(cpu, HV_X64_MSR_TSC_EMULATION_STATUS,
  89.                                   env->msr_hv_tsc_emulation_status);
  90.             }
  91.         }
  92.       ...
  93. }
  94. }

而HV_X64_MSR_REFERENCE_TSC对应的就是0x40000021寄存器地址，通过rdtsc指令获取该寄存器地址的值，以此计算时钟时间，未配置时不会设置寄存器地址，读取数据是无效的。

  1. /******************** include/qemu/timer.h ***********************/
  2. #elif defined(__i386__)
  4. static inline int64_t cpu_get_host_ticks(void)
  5. {
  6.     int64_t val;
  7.     asm volatile ("rdtsc" : "=A" (val));
  8.     return val;
  9. }
  11. #elif defined(__x86_64__)
  13. static inline int64_t cpu_get_host_ticks(void)
  14. {
  15.     uint32_t low,high;
  16.     int64_t val;
  17.     asm volatile("rdtsc" : "=a" (low), "=d" (high));
  18.     val = high;
  19.     val <<= 32;
  20.     val |= low;
  21.     return val;
  22. }

因此，此项配置下的时钟源，它的数据读取来源于rdtsc汇编指令的寄存器值，由于这个值是由host保持和更改的，kvm无法更改，所以使用此时钟源的所有的kvm，都可以保持与host的时间始终保持一致。

7、kvm-clock

kvmclock时钟时kvm环境特有的，且必须不配置-cpu kvm=off时才生效。首先来看下代码：

  1. /*************hw/i386/kvm/clock.c***************/
  2. /* Note: Must be called after VCPU initialization. */
  3. void kvmclock_create(void)
  4. {
  5.     X86CPU *cpu = X86_CPU(first_cpu);
  7.     if (kvm_enabled() &&
  8.         cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) |
  9.                                        (1ULL << KVM_FEATURE_CLOCKSOURCE2))) {
  10.         sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL);
  11.     }
  12. }
  14. int kvm_arch_init_vcpu(CPUState *cs)
  15. {
  16. ....
  17.     if (cpu->expose_kvm) { //kvm=off时条件不成立，不设置kvm=off时会被打上KVMKVMKVM标签
  18.         memcpy(signature, "KVMKVMKVM\0\0\0", 12);
  19.         c = &cpuid_data.entries[cpuid_i++];
  20.         c->function = KVM_CPUID_SIGNATURE | kvm_base;
  21.         c->eax = KVM_CPUID_FEATURES | kvm_base;
  22.         c->ebx = signature[0];
  23.         c->ecx = signature[1];
  24.         c->edx = signature[2];
  26.         c = &cpuid_data.entries[cpuid_i++];
  27.         c->function = KVM_CPUID_FEATURES | kvm_base;
  28.         c->eax = env->features[FEAT_KVM];
  29.         c->edx = env->features[FEAT_KVM_HINTS];
  30.     }
  31. ...
  32. }

以上代码总结下就是， CPUID[4000_0001].EAX标志由kvm=off/on决定，CPUID[4000_0001].EAX标志值影响内核判断当前环境是kvm环境还是非kvm环境，如果是kvm环境，则将提供kvm-clock时钟源做为一个可用的时钟源给kvm虚拟机使用，且之前提供kvm-clock的rating值为400，高于其他的时钟源，因此，一旦检测到环境为kvm环境，则kvm系统默认会使用kvm-clock时钟源。

而它的实现大致为

type_init(kvmclock_register_types)    /**** hw/i386/kvm/clock.c****/

|____ type_register_static(&kvmclock_info);    /**** kvmclock时钟源***/

|_____ kvmclock_class_init

它的数据读取来源于system_time_msr寄存器的读取。

8、qemu-kvm时钟总结

在前面章节我们依次简单说明了qemu-kvm中的时钟源模拟的代码实现路径以及一些核心的设计点，让我们来总结下，参考下表：

时钟源

qemu-kvm实现路径

模拟的频率

数据来源

时钟源rating值

RTC

hw/rtc/mc146818rtc.c

约为32KHZ

gettimeofday

NA

PIT

hw/i386/kvm/i8254.c和hw/timer/i8254.c

约为1.19MHZ

按照计数间隔计数，每次计数完成时间刷新

NA

TSC

NA

kvm cpu主频

kvm cpu的TSC寄存器

300

HPET

hw/timer/hpet.c

至少10MHZ

自己持有的全局结构体HPETState

250

ACPI（PM）

hw/acpi/core.c

约为3.57MHZ

acpi总线的acpi-tmr寄存器

200

Hyper-V

target/i386/kvm.c

与host cpu主频保持一致

rdtsc，host寄存器

400

kvmclock

hw/i386/kvm/clock.c

kvm cpu主频

kvm的system_time_msr

400

在目前的理论基础上，kvm的时钟优先级顺序应该是kvm-clock=Hyper-V> TSC>HPET>ACPI_PM。

那我们实际kvm中到底使用了哪个时钟源？这将在下面的实践中说明。

四、虚拟机中的时钟源实践

在背景前言章节提过，之所以调查研究时钟源问题，是因为在win10环境中发现，win10虚拟机stop的时间不会补偿，导致win10时钟不准。在调查过程中，我们发现配置kvm虚拟机不同的配置（-cpu配置）会影响时钟的补偿效果，大概总结如下：

1）在-cpu host时，gdb和stop的时间，win10虚拟机时钟都不会补偿；

2）在-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer时，gdb时间会补偿，stop时间不补偿；

3）在-cpu host,kvm=off时，gdb和stop时间都不补偿；

4）在-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，gdb和stop时间都会补偿；

感兴趣可以试下kvm中时钟在这些配置下的效果，接下来我们带着这些疑惑来进行实践，以此来分析kvm时钟同步的问题。由于windows代码不可见，我们无法分析windows时钟原理，我们先以linux（centos）为例，从理论上对kvm时钟进行解析。

前面提及过，RTC以外的时钟源是由cpu产生计数，时钟时间通过RTC时刻+计数次数*时钟源频率获取的当前时间的。那么时间的补偿与否，肯定和kvm cpu的状态有关，因为一旦cpu不再计数，那么时钟无论如何也无法得到正确的时间，只有当cpu正常计数时，时钟时间才能正常计算。

我们的问题就是再kvm stop后，时钟时间得不到补偿，从理论上推测，kvm stop和kvm start运行之间，kvm的cpu状态被改变了，从而导致cpu不再计数，从而导致系统除RTC以外的时钟源时间，全部丢失stop->start之间的时间。那么kvm stop时，到底对kvm的cpu都做了些什么？可以看如下代码片段（核心部分已加粗）：

  1. /***************cpus.c********************/
  2. ...
  3. void pause_all_vcpus(void)
  4. {
  5.     CPUState *cpu;
  7.     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false);
  8.     CPU_FOREACH(cpu) {
  9.         if (qemu_cpu_is_self(cpu)) {
  10.             qemu_cpu_stop(cpu, true);
  11.         } else {
  12.             cpu->stop = true;
  13.             qemu_cpu_kick(cpu);
  14.         }
  15.     }
  17.     /* We need to drop the replay_lock so any vCPU threads woken up
  18.      * can finish their replay tasks
  19.      */
  20.     replay_mutex_unlock();
  22.     while (!all_vcpus_paused()) {
  23.         qemu_cond_wait(&qemu_pause_cond, &qemu_global_mutex);
  24.         CPU_FOREACH(cpu) {
  25.             qemu_cpu_kick(cpu);
  26.         }
  27.     }
  29.     qemu_mutex_unlock_iothread();
  30.     replay_mutex_lock();
  31.     qemu_mutex_lock_iothread();
  32. }
  33. ...
  34. static int do_vm_stop(RunState state, bool send_stop)
  35. {
  36.     int ret = 0;
  38.     if (runstate_is_running()) {
  39.         cpu_disable_ticks();
  40.         pause_all_vcpus();
  41.         runstate_set(state);
  42.         vm_state_notify(0, state);
  43.         if (send_stop) {
  44.             qapi_event_send_stop();
  45.         }
  46.     }
  48.     bdrv_drain_all();
  49.     ret = bdrv_flush_all();
  51.     return ret;
  52. }
  53. ...
  54. void resume_all_vcpus(void)
  55. {
  56.     CPUState *cpu;
  58.     qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
  59.     CPU_FOREACH(cpu) {
  60.         cpu_resume(cpu);
  61.     }
  62. }
  63. ...
  64. int vm_stop(RunState state)
  65. {
  66.     if (qemu_in_vcpu_thread()) {
  67.         qemu_system_vmstop_request_prepare();
  68.         qemu_system_vmstop_request(state);
  69.         /*
  70.          * FIXME: should not return to device code in case
  71.          * vm_stop() has been requested.
  72.          */
  73.         cpu_stop_current();
  74.         return 0;
  75.     }
  77.     return do_vm_stop(state, true);
  78. }
  80. /**
  81.  * Prepare for (re)starting the VM.
  82.  * Returns -1 if the vCPUs are not to be restarted (e.g. if they are already
  83.  * running or in case of an error condition), 0 otherwise.
  84.  */
  85. int vm_prepare_start(void)
  86. {
  87.     RunState requested;
  89.     qemu_vmstop_requested(&requested);
  90.     if (runstate_is_running() && requested == RUN_STATE__MAX) {
  91.         return -1;
  92.     }
  94.     /* Ensure that a STOP/RESUME pair of events is emitted if a
  95.      * vmstop request was pending.  The BLOCK_IO_ERROR event, for
  96.      * example, according to documentation is always followed by
  97.      * the STOP event.
  98.      */
  99.     if (runstate_is_running()) {
  100.         qapi_event_send_stop();
  101.         qapi_event_send_resume();
  102.         return -1;
  103.     }
  105.     /* We are sending this now, but the CPUs will be resumed shortly later */
  106.     qapi_event_send_resume();
  108.     cpu_enable_ticks();
  109.     runstate_set(RUN_STATE_RUNNING);
  110.     vm_state_notify(1, RUN_STATE_RUNNING);
  111.     return 0;
  112. }
  114. void vm_start(void)
  115. {
  116.     if (!vm_prepare_start()) {
  117.         resume_all_vcpus();
  118.     }
  119. }

它的核心逻辑为：

/***************cpus.c***********************/

main

|__main_loop

       |___main_loop_should_exit

                |___vm_stop

                         |____qemu_system_vmstop_request_prepare()

                         |____qemu_system_vmstop_request(state)

                         |____cpu_stop_current()

                         |____do_vm_stop

                                |____ cpu_disable_ticks() //后面会再提及

                                |____ pause_all_vcpus()

                                        |____ qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false)

                                        |____ qemu_cpu_is_self(cpu)

                                                |____qemu_cpu_stop(cpu, true)

                                        |____ !qemu_cpu_is_self(cpu)

                                                |___ cpu->stop = true; qemu_cpu_kick(cpu);

vm_start

|________ vm_prepare_start()

              |____________________cpu_enable_ticks() //后面会再提及

|________ resume_all_vcpus()

              |____________________qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true)

              |___________________ cpu_resume(cpu)

在上述过程，我们可以看到，当kvm stop时，会将cpu设置成stop状态，且把qemu clock关闭；在继续运行时，把qemu clock使能，并唤醒cpu。因此，kvm stop时，kvm cpu被停止了，且qemu clock也被关闭，此时clock时钟计数均不会再增加和变化，当kvm start继续运行时，重新使能了qemu clock并唤醒cpu，但是系统中的时钟源数据都是stop时的数据，因此kvm系统时钟时间会丢失，从而得不到补偿。

这种stop后cpu计数和os时钟源停止计数，是符合时钟源的原理设定的，因为kvm的stop信号，相当于物理机的关机，关机后，理应停止所有cpu和os时钟。但物理机重启后，会重新读取RTC时刻，并初始化os时钟源，所以物理机时钟时间不会出问题。而kvm stop并不是kvm认为的关机，在qemu-kvm进程中，stop只是一个stop信号，主进程仍然在循环等待进程发出继续运行的中断指令，之后再继续运行。

那既然这样，我们该如何设置时钟源，让kvm即使在kvm stop时时钟源数据也保持正确呢。其实有两种方法：1）读取RTC时间；2）另外一种从host读取时钟源数据的方法，即hyperv_clocksource_tsc_page时钟源的数据。

1、linux（以centos为例）

首先，配置kvm虚拟机不同的配置（-cpu配置）会影响kvm系统中的可用时钟源和当前默认选择的时钟源配置，具体对应关系如下表：

-cpu参数

/sys/devices/system/clocksource/clocksource0/available_clocksource

/sys/devices/system/clocksource/clocksource0/current_clocksource

-cpu host

kvm-clock tsc acpi_pm

kvm-clock

-cpu host,kvm=off

tsc acpi_pm

tsc

-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer

kvm-clock tsc acpi_pm

kvm-clock

-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off

hyperv_clocksource_tsc_page acpi_pm

hyperv_clocksource_tsc_page

接下来，我们就依次来研究下，为什么在不同参数下，kvm中的可用时钟源会有所不同，进而影响当前正在使用的时钟源，从而导致虚拟环境中的时钟效果不同。

1）-cpu host时

本文前面分析过，不同时钟源的默认推荐优先级是不同的，它们的顺序是kvm-clock>Hyper-V> TSC（精度1纳秒或更小）>HPET（精度0.1毫秒或更小）>ACPI_PM（约0.3毫秒），而当我们仅仅配置-cpu host参数时，默认是所有时钟源都启用的，实际结果如下图：

我们看到此时，虚拟机中的可用时钟源有kvm-clock、tsc和acpi_pm，我们发现再kvm中可以被支持的可用的5个时钟源只出现了3个，其中：

1）没有hpet是因为我们还增加了-no-hpet参数，这里不再做扩展；

2）没有hyper-v是因为我们未配置hv_vpindex,hv_time,hv_synic,hv_stimer参数。

在当前可用时钟源为kvm-clock、tsc和acpi_pm时，系统默认选择了kvm-clock，这是因为第二章节中提及的linux内核中，kvm-clock的rating值为400，大于tsc（rating值为300）和acpi_pm(rating值为200)。

而前面我们说过，kvm-clock时钟源是依据os实现的cpu计数中断计算而来的时间，当kvm stop时，kvm cpu将完全处于关闭状态（同等物理机的关机），那么此时kvm-clock时钟源中的时间就不会再增加，因此，当kvm start继续运行时，stop->start之间的时间就没有得到计数，kvm中的时间就会丢失。

而此时，如果给虚拟机发送stop信号，虚拟机继续运行时，时钟时间没有得到补偿。

2）-cpu host,kvm=off时

我们看到此时，虚拟机中的可用时钟源有tsc和acpi_pm，我们发现再kvm中可以被支持的可用的5个时钟源只出现了2个，其中：

1）没有hpet是因为我们还增加了-no-hpet参数，这里不再做扩展；

2）没有hyper-v是因为我们未配置hv_vpindex,hv_time,hv_synic,hv_stimer参数；

3）而对比-cpu host时，kvm-clock时钟源也没了，这是受我们配置的kvm=off影响。

kvm=off影响cpu->expose_kvm值不同（off时为false）->进而影响env->features[FEAT_KVM]值（off时为0，否则不为0，即 CPUID[4000_0001].EAX (KVM_CPUID_FEATURES)中的值）->进而影响：off时不会创建kvmclock时钟。

  1. /*************hw/i386/kvm/clock.c***************/
  2. /* Note: Must be called after VCPU initialization. */
  3. void kvmclock_create(void)
  4. {
  5.     X86CPU *cpu = X86_CPU(first_cpu);
  7.     if (kvm_enabled() &&
  8.         cpu->env.features[FEAT_KVM] & ((1ULL << KVM_FEATURE_CLOCKSOURCE) |
  9.                                        (1ULL << KVM_FEATURE_CLOCKSOURCE2))) {
  10.         sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL);
  11.     }
  12. }
  14. int kvm_arch_init_vcpu(CPUState *cs)
  15. {
  16. ....
  17.     if (cpu->expose_kvm) { //kvm=off时条件不成立，不设置kvm=off时会被打上KVMKVMKVM标签
  18.         memcpy(signature, "KVMKVMKVM\0\0\0", 12);
  19.         c = &cpuid_data.entries[cpuid_i++];
  20.         c->function = KVM_CPUID_SIGNATURE | kvm_base;
  21.         c->eax = KVM_CPUID_FEATURES | kvm_base;
  22.         c->ebx = signature[0];
  23.         c->ecx = signature[1];
  24.         c->edx = signature[2];
  26.         c = &cpuid_data.entries[cpuid_i++];
  27.         c->function = KVM_CPUID_FEATURES | kvm_base;
  28.         c->eax = env->features[FEAT_KVM];
  29.         c->edx = env->features[FEAT_KVM_HINTS];
  30.     }
  31. ...
  32. }

在kvmclock_create()接口中，一旦符合条件，将创建一个kvm-clock时钟源的sysbus，从而使能kvm-clock时钟源，这里是否执行sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL)，并且受我们启用qemu-kvm进程时的配置影响的主要为两个方面：1）kvm_enabled()的返回值；2）cpu->env.features[FEAT_KVM]的值。

kvm_enabled()和cpu->env.features[FEAT_KVM]这两个值就不展开讲了，总结下就是：①-accel accel=kvm控制kvm_enabled()为真，配置为其他的则不成立；②kvm=off控制cpu->env.features[FEAT_KVM]=0，不配置时默认为1。

因此，当我们配置kvm=off时，不会再执行 sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL)。除此之外，kvm=off可以总结影响3个方面：① CPUID[4000_0001].EAX标志off时由1变为0，cpuid里面的KVM标志被抹掉了②不再执行sysbus_create_simple(TYPE_KVM_CLOCK, -1, NULL);创建一个kvm clock；③vmstate中有4个msr_entry不再设置，分别是MSR_KVM_ASYNC_PF_EN、MSR_KVM_PV_EOI_EN、MSR_KVM_STEAL_TIME、MSR_KVM_POLL_CONTROL。而kvm-clock是否支持可用，在内核中就是通过CPUID[4000_0001].EAX标志判断当前环境是否为kvm决定的，一旦当前环境的CPUID[4000_0001].EAX标志被设置为1，则仍为时kvm环境，提供kvm-clock的支持，提供给系统做为可用时钟源。

那么在当前可用时钟源为tsc和acpi_pm时，系统默认选择了tsc，这是因为第二章节中提及的linux内核中， tsc的rating值为300，大于acpi_pm的rating值200。

而前面我们说过，tsc时钟源也是依据os实现的cpu计数中断计算而来的时间，当kvm stop时，kvm cpu将完全处于关闭状态（同等物理机的关机），那么此时tsc时钟源中的时间就不会再增加，因此，当kvm start继续运行时，stop->start之间的时间就没有得到计数，kvm中的时间也同样会丢失。

而此时，如果给虚拟机发送stop信号，虚拟机继续运行时，时钟时间没有得到补偿。

3）-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer时

我们看到此时，虚拟机中的可用时钟源有kvm-clock、tsc和acpi_pm，我们发现再kvm中可以被支持的可用的5个时钟源只出现了3个，其中：

1）没有hpet是因为我们还增加了-no-hpet参数，这里不再做扩展；

2）没有hyper-v是因为我们虽然配置了hv_vpindex,hv_time,hv_synic,hv_stimer参数，但是由于qemu-kvm中的代码逻辑，没有设置tsc相关的寄存器配置，导致系统无法识别，此时，仍然hyper-V时钟源不会出现。

在当前可用时钟源为kvm-clock、tsc和acpi_pm时，系统默认选择了kvm-clock，这是因为第二章节中提及的linux内核中，kvm-clock的rating值为400，大于tsc（rating值为300）和acpi_pm(rating值为200)。

而前面我们说过，kvm-clock时钟源是依据os实现的cpu计数中断计算而来的时间，当kvm stop时，kvm cpu将完全处于关闭状态（同等物理机的关机），那么此时kvm-clock时钟源中的时间就不会再增加，因此，当kvm start继续运行时，stop->start之间的时间就没有得到计数，kvm中的时间就会丢失。

而此时，如果给虚拟机发送stop信号，虚拟机继续运行时，时钟时间没有得到补偿。

4）-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时

我们看到此时，虚拟机中的可用时钟源有hyperv_clocksource_tsc_page和acpi_pm，我们发现再kvm中可以被支持的可用的5个时钟源只出现了2个，相比前面的配置，多了hyperv_clocksource_tsc_page时钟源，其中：

1)没有hpet是因为我们还增加了-no-hpet参数，这里不再做扩展；

2)出现了hyperv_clocksource_tsc_page是因为我们配置了hv_vpindex,hv_time,hv_synic,hv_stimer参数；

在介绍kernel时钟原理和实现中介绍Hyper-V时我们说过，Hyper-V提供两个时钟源计数器，分别为hyperv_clocksource_msr和hyperv_clocksource_tsc_page，当hyperv_clocksource_tsc_page支持（由内核编译选项CONFIG_HYPERV_TSCPAGE控制，受系统内核编译时配置影响）时，则不再使用hyperv_clocksource_msr时钟源。在启用kvm时，会根据kvm的启动设置，即下方代码的if (ms_hyperv.features & HV_X64_MSR_REFERENCE_TSC_AVAILABLE)语句成立，在检测到虚拟机管理程序后在引导序列的早期调用hyperv_init()初始化，如果配置了hyperv特性以及使能了HYPERV_TSCPAGE则从hyperv_clocksource_tsc_page获取时钟源。当hyperv_clocksource_tsc_page不支持时则从hyperv_clocksource_msr获取时钟源（我们环境不是这样的，不介绍了）。

而hyperv_clocksource_tsc_page的出现，正因为hv_vpindex,hv_time,hv_synic,hv_stimer参数的配置。先看如下代码：

  1. /*********************target/i386/kvm.c**************************/
  2. static struct {
  3.     const char *desc;
  4.     struct {
  5.         uint32_t fw;
  6.         uint32_t bits;
  7.     } flags[2];
  8.     uint64_t dependencies;
  9. } kvm_hyperv_properties[] = {
  10.     [HYPERV_FEAT_RELAXED] = {
  11.         .desc = "relaxed timing (hv-relaxed)",
  12.         .flags = {
  13.             {.fw = FEAT_HYPERV_EAX,
  14.              .bits = HV_HYPERCALL_AVAILABLE},
  15.             {.fw = FEAT_HV_RECOMM_EAX,
  16.              .bits = HV_RELAXED_TIMING_RECOMMENDED}
  17.         }
  18.     },
  19.     [HYPERV_FEAT_VAPIC] = {
  20.         .desc = "virtual APIC (hv-vapic)",
  21.         .flags = {
  22.             {.fw = FEAT_HYPERV_EAX,
  23.              .bits = HV_HYPERCALL_AVAILABLE | HV_APIC_ACCESS_AVAILABLE},
  24.             {.fw = FEAT_HV_RECOMM_EAX,
  25.              .bits = HV_APIC_ACCESS_RECOMMENDED}
  26.         }
  27.     },
  28.     [HYPERV_FEAT_TIME] = {
  29.         .desc = "clocksources (hv-time)",
  30.         .flags = {
  31.             {.fw = FEAT_HYPERV_EAX,
  32.              .bits = HV_HYPERCALL_AVAILABLE | HV_TIME_REF_COUNT_AVAILABLE |
  33.              HV_REFERENCE_TSC_AVAILABLE}
  34.         }
  35.     },
  36.     ...
  37. }

一旦我们在启动qemu-kvm时配置了hv_time选项，那么此时就使能了HV_X64_MSR_REFERENCE_TSC。参考如下代码：

  1. /****************target/i386/kvm.c****************************/
  2. static int kvm_get_msrs(X86CPU *cpu)
  3. {
  4. ...
  5.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_ASYNC_PF)) {
  6.         kvm_msr_entry_add(cpu, MSR_KVM_ASYNC_PF_EN, 0);
  7.     }
  8.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_PV_EOI)) {
  9.         kvm_msr_entry_add(cpu, MSR_KVM_PV_EOI_EN, 0);
  10.     }
  11.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_STEAL_TIME)) {
  12.         kvm_msr_entry_add(cpu, MSR_KVM_STEAL_TIME, 0);
  13.     }
  14.     if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_POLL_CONTROL)) {
  15.         kvm_msr_entry_add(cpu, MSR_KVM_POLL_CONTROL, 1);
  16.     }
  17. ...
  18.     if (has_msr_hv_hypercall) {
  19.         kvm_msr_entry_add(cpu, HV_X64_MSR_HYPERCALL, 0);
  20.         kvm_msr_entry_add(cpu, HV_X64_MSR_GUEST_OS_ID, 0);
  21.     }
  22.     if (hyperv_feat_enabled(cpu, HYPERV_FEAT_VAPIC)) {
  23.         kvm_msr_entry_add(cpu, HV_X64_MSR_APIC_ASSIST_PAGE, 0);
  24.     }
  25.     if (hyperv_feat_enabled(cpu, HYPERV_FEAT_TIME)) {
  26.         kvm_msr_entry_add(cpu, HV_X64_MSR_REFERENCE_TSC, 0);
  27.     }
  28. ...
  29. ret = kvm_vcpu_ioctl(CPU(cpu), KVM_GET_MSRS, cpu->kvm_msr_buf);
  30.     if (ret < 0) {
  31.         return ret;
  32.     }
  33. ...
  34.     for (i = 0; i < ret; i++) {
  35.         uint32_t index = msrs[i].index;
  36.         switch (index) {
  37.       ...
  38.         case HV_X64_MSR_REFERENCE_TSC:
  39.             env->msr_hv_tsc = msrs[i].data;
  40.       ...
  41.       }
  42. }
  43. ...
  44. }
  47. static int kvm_put_msrs(X86CPU *cpu, int level)
  48. {
  49. ...
  50.     if (level >= KVM_PUT_RESET_STATE) {
  51.         kvm_msr_entry_add(cpu, MSR_IA32_TSC, env->tsc);
  52.         kvm_msr_entry_add(cpu, MSR_KVM_SYSTEM_TIME, env->system_time_msr);
  53.         kvm_msr_entry_add(cpu, MSR_KVM_WALL_CLOCK, env->wall_clock_msr);
  54.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_ASYNC_PF)) {
  55.             kvm_msr_entry_add(cpu, MSR_KVM_ASYNC_PF_EN, env->async_pf_en_msr);
  56.         }
  57.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_PV_EOI)) {
  58.             kvm_msr_entry_add(cpu, MSR_KVM_PV_EOI_EN, env->pv_eoi_en_msr);
  59.         }
  60.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_STEAL_TIME)) {
  61.             kvm_msr_entry_add(cpu, MSR_KVM_STEAL_TIME, env->steal_time_msr);
  62.         }
  64.         if (env->features[FEAT_KVM] & (1 << KVM_FEATURE_POLL_CONTROL)) {
  65.             kvm_msr_entry_add(cpu, MSR_KVM_POLL_CONTROL, env->poll_control_msr);
  66.         }
  67.       ...
  68.         /*
  69.          * Hyper-V partition-wide MSRs: to avoid clearing them on cpu hot-add,
  70.          * only sync them to KVM on the first cpu
  71.          */
  72.         if (current_cpu == first_cpu) {
  73.             if (has_msr_hv_hypercall) {
  74.                 kvm_msr_entry_add(cpu, HV_X64_MSR_GUEST_OS_ID,
  75.                                   env->msr_hv_guest_os_id);
  76.                 kvm_msr_entry_add(cpu, HV_X64_MSR_HYPERCALL,
  77.                                   env->msr_hv_hypercall);
  78.             }
  79.             if (hyperv_feat_enabled(cpu, HYPERV_FEAT_TIME)) {
  80.                 kvm_msr_entry_add(cpu, HV_X64_MSR_REFERENCE_TSC,
  81.                                   env->msr_hv_tsc);
  82.             }
  83.             if (hyperv_feat_enabled(cpu, HYPERV_FEAT_REENLIGHTENMENT)) {
  84.                 kvm_msr_entry_add(cpu, HV_X64_MSR_REENLIGHTENMENT_CONTROL,
  85.                                   env->msr_hv_reenlightenment_control);
  86.                 kvm_msr_entry_add(cpu, HV_X64_MSR_TSC_EMULATION_CONTROL,
  87.                                   env->msr_hv_tsc_emulation_control);
  88.                 kvm_msr_entry_add(cpu, HV_X64_MSR_TSC_EMULATION_STATUS,
  89.                                   env->msr_hv_tsc_emulation_status);
  90.             }
  91.         }
  92.       ...
  93. }
  94. }

而HV_X64_MSR_REFERENCE_TSC对应的就是0x40000021寄存器地址，通过rdtsc指令获取该寄存器地址的值，以此计算时钟时间，未配置时不会设置寄存器地址，读取数据是无效的。

  1. /******************** include/qemu/timer.h ***********************/
  2. #elif defined(__i386__)
  4. static inline int64_t cpu_get_host_ticks(void)
  5. {
  6.     int64_t val;
  7.     asm volatile ("rdtsc" : "=A" (val));
  8.     return val;
  9. }
  11. #elif defined(__x86_64__)
  13. static inline int64_t cpu_get_host_ticks(void)
  14. {
  15.     uint32_t low,high;
  16.     int64_t val;
  17.     asm volatile("rdtsc" : "=a" (low), "=d" (high));
  18.     val = high;
  19.     val <<= 32;
  20.     val |= low;
  21.     return val;
  22. }

而cpu_get_host_ticks调用时间就是在kvm cpu stop和start流程中设置

  1. /********************** cpus.c ***************************/
  2. /* enable cpu_get_ticks()
  3.  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
  4.  */
  5. void cpu_enable_ticks(void)
  6. {
  7.     seqlock_write_lock(&timers_state.vm_clock_seqlock,
  8.                        &timers_state.vm_clock_lock);
  9.     if (!timers_state.cpu_ticks_enabled) {
  10.         timers_state.cpu_ticks_offset -= cpu_get_host_ticks();
  11.         timers_state.cpu_clock_offset -= get_clock();
  12.         timers_state.cpu_ticks_enabled = 1;
  13.     }
  14.     seqlock_write_unlock(&timers_state.vm_clock_seqlock,
  15.                        &timers_state.vm_clock_lock);
  16. }
  18. /* disable cpu_get_ticks() : the clock is stopped. You must not call
  19.  * cpu_get_ticks() after that.
  20.  * Caller must hold BQL which serves as mutex for vm_clock_seqlock.
  21.  */
  22. void cpu_disable_ticks(void)
  23. {
  24.     seqlock_write_lock(&timers_state.vm_clock_seqlock,
  25.                        &timers_state.vm_clock_lock);
  26.     if (timers_state.cpu_ticks_enabled) {
  27.         timers_state.cpu_ticks_offset += cpu_get_host_ticks();
  28.         timers_state.cpu_clock_offset = cpu_get_clock_locked();
  29.         timers_state.cpu_ticks_enabled = 0;
  30.     }
  31.     seqlock_write_unlock(&timers_state.vm_clock_seqlock,
  32.                          &timers_state.vm_clock_lock);
  33. }

前面我们说过，kvm stop和start它的核心逻辑为：

/***************cpus.c***********************/

main

|__main_loop

       |___main_loop_should_exit

                |___vm_stop

                         |____qemu_system_vmstop_request_prepare()

                         |____qemu_system_vmstop_request(state)

                         |____cpu_stop_current()

                         |____do_vm_stop

                                |____ cpu_disable_ticks()

                                      |____ cpu_get_host_ticks() //里面调用rdtsc读取0x40000021寄存器地址值，未配置hv_time时获取不到，未配置kvm=off时会被kvm-clock抢先优先作为kvm时钟源

                                |____ pause_all_vcpus()

                                        |____ qemu_clock_enable(QEMU_CLOCK_VIRTUAL, false)

                                        |____ qemu_cpu_is_self(cpu)

                                                |____qemu_cpu_stop(cpu, true)

                                        |____ !qemu_cpu_is_self(cpu)

                                                |___ cpu->stop = true; qemu_cpu_kick(cpu);

vm_start

|________ vm_prepare_start()

              |____________________cpu_enable_ticks()

                                   |____ cpu_get_host_ticks() //里面调用rdtsc读取0x40000021寄存器地址值，未配置hv_time时获取不到，未配置kvm=off时会被kvm-clock抢先优先作为kvm时钟源

|________ resume_all_vcpus()

              |____________________qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true)

              |___________________ cpu_resume(cpu)

因此，我们配置-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，会出现hyperv_clocksource_tsc_page时钟源，而hyperv_clocksource_tsc_page时钟源因为在vm_stop和vm_start期间，都会去通过rdtsc读取host的cpu计数时间，从而hyperv_clocksource_tsc_page时钟源在kvm stop和start期间的时钟时间也不会丢失，且进入系统后，应该是时钟立马跳到正确的时间，不会慢慢调整。而实际现象，也正如我们分析的这样。

3）而对比-cpu host时，kvm-clock时钟源也没了，上面章节讲过，不再赘述。

在当前可用时钟源为hyperv_clocksource_tsc_page和acpi_pm时，系统默认选择了hyperv_clocksource_tsc_page，这是因为第二章节中提及的linux内核中， hyperv_clocksource_tsc_page的rating值为400，大于acpi_pm的rating值200。

然而前面我们说过，os时钟源也是依据os实现的cpu计数中断计算而来的时间，当kvm stop时，kvm cpu将完全处于关闭状态（同等物理机的关机），那么此时时钟源中的时间就不会再增加，因此，当kvm start继续运行时，stop->start之间的时间就没有得到计数，kvm中的时间应该会丢失。而hyperv_clocksource_tsc_page时钟源因为在vm_stop和vm_start期间，都会去通过rdtsc读取host的cpu计数，从而hyperv_clocksource_tsc_page时钟源在kvm stop和start期间的时钟时间也不会丢失，且进入系统后，应该是时钟立马跳到正确的时间，不会慢慢调整。

5）总结

从上述分析对比发现，linux支持的时钟源中hyperv_clocksource_tsc_page和RTC是从host读取的时间做为kvm时钟源时间数据的，因此，我们要想kvm系统时钟时间不会导致stop后时间丢失，那就只有在启动qemu-kvm进程时配置-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off参数，gdb和stop时间才都会得到补偿，所以要想kvm中的时钟保持和host一致，我们应该配置这个参数，否则将导致kvm stop的时钟源丢失stop时间，从而导致系统时钟时间可能不准。

2、windows10

前面我们提及过，win10时钟时间的补偿效果受-cpu配置参数的不同会有不同的表现：

1）在-cpu host时，gdb和stop的时间，win10虚拟机时钟都不会补偿；

2）在-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer时，gdb时间会补偿，stop时间不补偿；

3）在-cpu host,kvm=off时，gdb和stop时间都不补偿；

4）在-cpu host,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，gdb和stop时间都会补偿；

在经过以上章节可以得知，-cpu后续配置会影响kvm中可用时钟源。而在linux（以centos为例）中，我们经过验证以及依据linux kernel时钟源原理可以总结出以下内容：

-cpu参数

/sys/devices/system/clocksource/clocksource0/available_clocksource

/sys/devices/system/clocksource/clocksource0/current_clocksource

-cpu host

kvm-clock tsc acpi_pm

kvm-clock

-cpu host,kvm=off

tsc acpi_pm

tsc

-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer

kvm-clock tsc acpi_pm

kvm-clock

-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off

hyperv_clocksource_tsc_page acpi_pm

hyperv_clocksource_tsc_page

然而windows内核我们并不可见，无法探索研究win内核时钟源原理，但是从实际现象上看，win10上在未配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，时钟时间在stop后会无法得到补偿，可以推断win内核中的时钟源设计应该适合linux相一致的。

为了研究win10到底在运行时使用了哪个时钟源，通过在gdb跟踪qemu-kvm进程（并设置断点kvm_update_clock）时发现：

①加了配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时

kvm_update_clock断点stop后不会被触发到，证明kvm_update_clock不会被调用

②不加配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时

kvm_update_clock会被stop后会被触发到，证明kvm_update_clock会被调用

而kvm_update_clock就是kvm-clock的时钟源的接口，因此也可以判断在不加-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，win10虚拟机使用的时kvm-clock时钟源，加了后就会使用hyperv_clocksource_tsc_page acpi_pm中的某一个时钟源。

而我们打上acpi_pm时钟源的读写操作断点时，gdb时钟不会触发断点，因此证明几点内容：1）未配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，win10使用kvm-clock时钟源；2）配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off时，win10使用hyperv_clocksource_tsc_page时钟源。

因此，在使用win10 kvm虚拟机时，我们在启动qemu-kvm进程时，也应该为win10 kvm虚拟机配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off参数，让kvm虚拟机的时钟时间保持和host一致，从而解决win10 kvm stop后丢失stop期间的时钟时间。

3、windows7

前面说过，win10只有配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off参数时，kvm系统时钟时间才不会在stop后丢失stop期间的时钟时间，但是在使用win7虚拟机时发现，win7系统的时钟时间，无论是否配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off参数，kvm中的系统时钟时间始终会得到补偿。那这又是为什么呢？

前面我们也提及过，kvm保持和host时钟同步的时钟源其实有两种，一种时通过配置参数-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off 配置生效的hyperv_clocksource_tsc_page时钟源，还有一个就是RTC时钟源。那既然在win7中无论是否使用hyperv_clocksource_tsc_page时钟源，kvm系统的时钟时间都正确，那以此推断，win7时钟源其实使用的是RTC时钟源。那我们又该如何取证呢？

接下来，让我们来对比下win10和win7在系统运行过程中，在host中通过qemu-kvm进程观察两个系统的ioport事件，看看是否有存在差异。我们使用perf kvm stat record -p $pid sleep 30来跟踪qemu-kvm进程的ioport事件情况（注意：尽量保持虚拟机在系统就绪中，并保持系统空载，防止其他因素影响我们的观察结果），并通过perf kvm stat report --event=ioport -p $pid来观察ioport结果。

1）配置-cpu host

Perf跟踪的结果发现，ioport事件中，win10和win7几乎一致，主要的ioport事件有3个，分别为1）0x608:PIN；2）0x71:PIN；3）0x70:POUT。实际结果如下：

2）配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer

Perf跟踪的结果发现，ioport事件中，win10和win7就不再一致了，win7主要的ioport事件有：1）0x71:PIN；2）0x70:POUT；3）0x1f7:PIN；4）0xc040:POUT。而win10缺少了两个ioport事件：1）0x71:PIN；2）0x70:POUT。实际结果如下：

3）配置-cpu host ,hv_vpindex,hv_time,hv_synic,hv_stimer,kvm=off

Perf跟踪的结果发现，ioport事件中，win10和win7就不再一致了，win7主要的ioport事件有：1）0x71:PIN；2）0x70:POUT；3）0x1f7:PIN；4）0xc040:POUT。而win10只有1）0x1f7:PIN；2）0xc040:POUT。缺少了两个ioport事件：1）0x71:PIN；2）0x70:POUT。实际结果如下：

也许你会好奇，为啥win10配置参数后，rtc时钟为啥不更新了，这其实是因为hv特性导致的。Qemu-kvm中增加了hv特性相关的设置，以此来优化kvm的性能问题，在docs/hyperv.txt说明文档中由这么一段话

感兴趣的可以去研究下，这里不展开讲述了。

那上面那些统计的ioport事件到底是代表什么含义，我们可以通过qemu-kvm的mtree查询。贴上我从qemu的mstree查询到的结果。

address-space: I/O

    0000000000000000-000000000000ffff (prio 0, i/o): io

    0000000000000000-0000000000000007 (prio 0, i/o): dma-chan

    0000000000000008-000000000000000f (prio 0, i/o): dma-cont

    0000000000000020-0000000000000021 (prio 0, i/o): kvm-pic

    0000000000000040-0000000000000043 (prio 0, i/o): kvm-pit

    0000000000000060-0000000000000060 (prio 0, i/o): i8042-data

    0000000000000061-0000000000000061 (prio 0, i/o): pcspk

    0000000000000064-0000000000000064 (prio 0, i/o): i8042-cmd

    0000000000000070-0000000000000071 (prio 0, i/o): rtc

      0000000000000070-0000000000000070 (prio 0, i/o): rtc-index

    000000000000007e-000000000000007f (prio 0, i/o): kvmvapic

    0000000000000080-0000000000000080 (prio 0, i/o): ioport80

    0000000000000081-0000000000000083 (prio 0, i/o): dma-page

    0000000000000087-0000000000000087 (prio 0, i/o): dma-page

    0000000000000089-000000000000008b (prio 0, i/o): dma-page

    000000000000008f-000000000000008f (prio 0, i/o): dma-page

    0000000000000092-0000000000000092 (prio 0, i/o): port92

    00000000000000a0-00000000000000a1 (prio 0, i/o): kvm-pic

    00000000000000b2-00000000000000b3 (prio 0, i/o): apm-io

    00000000000000c0-00000000000000cf (prio 0, i/o): dma-chan

    00000000000000d0-00000000000000df (prio 0, i/o): dma-cont

    00000000000000f0-00000000000000f0 (prio 0, i/o): ioportF0

    0000000000000170-0000000000000177 (prio 0, i/o): ide

    00000000000001ce-00000000000001d1 (prio 0, i/o): vbe

    00000000000001f0-00000000000001f7 (prio 0, i/o): ide

    0000000000000376-0000000000000376 (prio 0, i/o): ide

    00000000000003b4-00000000000003b5 (prio 0, i/o): vga

    00000000000003ba-00000000000003ba (prio 0, i/o): vga

    00000000000003c0-00000000000003cf (prio 0, i/o): vga

    00000000000003d4-00000000000003d5 (prio 0, i/o): vga

    00000000000003da-00000000000003da (prio 0, i/o): vga

    00000000000003f1-00000000000003f5 (prio 0, i/o): fdc

    00000000000003f6-00000000000003f6 (prio 0, i/o): ide

    00000000000003f7-00000000000003f7 (prio 0, i/o): fdc

    00000000000003f8-00000000000003ff (prio 0, i/o): serial

    00000000000004d0-00000000000004d0 (prio 0, i/o): kvm-elcr

    00000000000004d1-00000000000004d1 (prio 0, i/o): kvm-elcr

    0000000000000510-0000000000000511 (prio 0, i/o): fwcfg

    0000000000000514-000000000000051b (prio 0, i/o): fwcfg.dma

    0000000000000600-000000000000063f (prio 0, i/o): piix4-pm

      0000000000000600-0000000000000603 (prio 0, i/o): acpi-evt

      0000000000000604-0000000000000605 (prio 0, i/o): acpi-cnt

      0000000000000608-000000000000060b (prio 0, i/o): acpi-tmr

    0000000000000700-000000000000073f (prio 0, i/o): pm-smbus

    0000000000000cf8-0000000000000cfb (prio 0, i/o): pci-conf-idx

    0000000000000cf9-0000000000000cf9 (prio 1, i/o): piix3-reset-control

    0000000000000cfc-0000000000000cff (prio 0, i/o): pci-conf-data

    0000000000005658-0000000000005658 (prio 0, i/o): vmport

    000000000000ae00-000000000000ae13 (prio 0, i/o): acpi-pci-hotplug

    000000000000af00-000000000000af0b (prio 0, i/o): acpi-mem-hotplug

    000000000000afe0-000000000000afe3 (prio 0, i/o): acpi-gpe0

    000000000000c040-000000000000c04f (prio 1, i/o): piix-bmdma-container

      000000000000c040-000000000000c043 (prio 0, i/o): piix-bmdma

      000000000000c044-000000000000c047 (prio 0, i/o): bmdma

      000000000000c048-000000000000c04b (prio 0, i/o): piix-bmdma

      000000000000c04c-000000000000c04f (prio 0, i/o): bmdma

通过对比mstree信息，可以总结如下：

-cpu配置参数

Win7的ioport事件

Win10的ioport事件

host

1)0000000000000070-0000000000000071 (prio 0, i/o): rtc

2)0000000000000070-0000000000000070 (prio 0, i/o): rtc-index

3)0000000000000608-000000000000060b (prio 0, i/o): acpi-tmr

0000000000000070-0000000000000071 (prio 0, i/o): rtc

0000000000000070-0000000000000070 (prio 0, i/o): rtc-index

0000000000000608-000000000000060b (prio 0, i/o): acpi-tmr

host ,

hv_vpindex,

hv_time,

hv_synic,

hv_stimer

1)00000000000001f0-00000000000001f7 (prio 0, i/o): ide

2)000000000000c040-000000000000c04f (prio 1, i/o): piix-bmdma-container

3)0000000000000070-0000000000000071 (prio 0, i/o): rtc

4)0000000000000070-0000000000000070 (prio 0, i/o): rtc-index

1)00000000000001f0-00000000000001f7 (prio 0, i/o): ide

2)000000000000c040-000000000000c04f (prio 1, i/o): piix-bmdma-container

host ,

hv_vpindex,

hv_time,

hv_synic,

hv_stimer,

kvm=off

1)0000000000000070-0000000000000071 (prio 0, i/o): rtc

2)0000000000000070-0000000000000070 (prio 0, i/o): rtc-index

1)00000000000001f0-00000000000001f7 (prio 0, i/o): ide

2)000000000000c040-000000000000c04f (prio 1, i/o): piix-bmdma-container

通过上表我们对比发现，无论win7虚拟机如何配置参数，系统运行时始终会去触发rtc的ioport事件，也就是去读取rtc时钟源时间。而win10虚拟机，在配置了hv相关配置后，在系统运行时就不会再去读取rtc时钟源时间，而会去读取00000000000001f0-00000000000001f7 (prio 0, i/o): ide中的数据，这个io其实是ide数据，即寄存器数据，这里可以理解为其他时钟源的数据。

此外，我们还发现，一旦配置-rtc driftfix=none（不为slew）时，则win7的时钟时间，在stop后也不会得到补偿，这个原因可以看以下代码（重点位置已经标红加粗）

  1. /******************vl.c**************/
  2. static void configure_rtc(QemuOpts *opts)
  3. {
  4.     const char *value;
  6.     /* Set defaults */
  7.     rtc_clock = QEMU_CLOCK_HOST;
  8.     rtc_ref_start_datetime = qemu_clock_get_ms(QEMU_CLOCK_HOST) / 1000;
  9.     rtc_realtime_clock_offset = qemu_clock_get_ms(QEMU_CLOCK_REALTIME) / 1000;
  11.     value = qemu_opt_get(opts, "base");
  12.     if (value) {
  13.         if (!strcmp(value, "utc")) {
  14.             rtc_base_type = RTC_BASE_UTC;
  15.         } else if (!strcmp(value, "localtime")) {
  16.             Error *blocker = NULL;
  17.             rtc_base_type = RTC_BASE_LOCALTIME;
  18.             error_setg(&blocker, QERR_REPLAY_NOT_SUPPORTED,
  19.                       "-rtc base=localtime");
  20.             replay_add_blocker(blocker);
  21.         } else {
  22.             rtc_base_type = RTC_BASE_DATETIME;
  23.             configure_rtc_base_datetime(value);
  24.         }
  25.     }
  26.     value = qemu_opt_get(opts, "clock");
  27.     if (value) {
  28.         if (!strcmp(value, "host")) {
  29.             rtc_clock = QEMU_CLOCK_HOST;
  30.         } else if (!strcmp(value, "rt")) {
  31.             rtc_clock = QEMU_CLOCK_REALTIME;
  32.         } else if (!strcmp(value, "vm")) {
  33.             rtc_clock = QEMU_CLOCK_VIRTUAL;
  34.         } else {
  35.             error_report("invalid option value '%s'", value);
  36.             exit(1);
  37.         }
  38.     }
  39.     value = qemu_opt_get(opts, "driftfix");
  40.     if (value) {
  41.         if (!strcmp(value, "slew")) {
  42.             static GlobalProperty slew_lost_ticks = {
  43.                 .driver   = "mc146818rtc",
  44.                 .property = "lost_tick_policy",
  45.                 .value    = "slew",
  46.             };
  48.             qdev_prop_register_global(&slew_lost_ticks);
  49.         } else if (!strcmp(value, "none")) {
  50.             /* discard is default */
  51.         } else {
  52.             error_report("invalid option value '%s'", value);
  53.             exit(1);
  54.         }
  55.     }
  56. }

可以发现，一旦我们未配置driftfix=slew，则不会设置mc146818rtc的lost_tick_policy策略，从而导致后续在rtc调用时钟时间更新接口时，在stop后，rtc时钟源不会重新从host获取。代码如下：

  1. static void
  2. periodic_timer_update(RTCState *s, int64_t current_time, uint32_t old_period, bool period_change)
  3. {
  4.     ...
  5.     /*
  6.      * s->irq_coalesced can change for two reasons:
  7.      *
  8.      * a) if one or more periodic timer interrupts have been lost,
  9.      *    lost_clock will be more that a period.
  10.      *
  11.      * b) when the period may be reconfigured, we expect the OS to
  12.      *    treat delayed tick as the new period.  So, when switching
  13.      *    from a shorter to a longer period, scale down the missing,
  14.      *    because the OS will treat past delayed ticks as longer
  15.      *    (leftovers are put back into lost_clock).  When switching
  16.      *    to a shorter period, scale up the missing ticks since the
  17.      *    OS handler will treat past delayed ticks as shorter.
  18.      */
  19.     if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
  20.         uint32_t old_irq_coalesced = s->irq_coalesced;
  22.         lost_clock += old_irq_coalesced * old_period;
  23.         s->irq_coalesced = lost_clock / s->period;
  24.         lost_clock %= s->period;
  25.         if (old_irq_coalesced != s->irq_coalesced ||
  26.             old_period != s->period) {
  27.             DPRINTF_C("cmos: coalesced irqs scaled from %d to %d, "
  28.                       "period scaled from %d to %d\n", old_irq_coalesced,
  29.                       s->irq_coalesced, old_period, s->period);
  30.             rtc_coalesced_timer_update(s);
  31.         }
  32.     } else {
  33.         /*
  34.          * no way to compensate the interrupt if LOST_TICK_POLICY_SLEW
  35.          * is not used, we should make the time progress anyway.
  36.          */
  37.         lost_clock = MIN(lost_clock, period);
  38.     }
  39.     ...
  40. }
  41. static void rtc_periodic_timer(void *opaque)
  42. {
  43.     RTCState *s = opaque;
  45.     periodic_timer_update(s, s->next_periodic_time, s->period, false);
  46.     s->cmos_data[RTC_REG_C] |= REG_C_PF;
  47.     if (s->cmos_data[RTC_REG_B] & REG_B_PIE) {
  48.         s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
  49.         if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
  50.             if (s->irq_reinject_on_ack_count >= RTC_REINJECT_ON_ACK_COUNT)
  51.                 s->irq_reinject_on_ack_count = 0;
  52.             if (!rtc_policy_slew_deliver_irq(s)) {
  53.                 s->irq_coalesced++;
  54.                 rtc_coalesced_timer_update(s);
  55.                 DPRINTF_C("cmos: coalesced irqs increased to %d\n",
  56.                           s->irq_coalesced);
  57.             }
  58.         } else
  59.             qemu_irq_raise(s->irq);
  60.     }
  61. }

我们发现它会在更新rtc时间的时候，调用rtc_coalesced_timer_update以重新获取设置RTC时间，它的实现如下：

  1. static void rtc_coalesced_timer_update(RTCState *s)
  2. {
  3.     if (s->irq_coalesced == 0) {
  4.         timer_del(s->coalesced_timer);
  5.     } else {
  6.         /* divide each RTC interval to 2 - 8 smaller intervals */
  7.         int c = MIN(s->irq_coalesced, 7) + 1;
  8.         int64_t next_clock = qemu_clock_get_ns(rtc_clock) +
  9.             periodic_clock_to_ns(s->period / c);
  10.         timer_mod(s->coalesced_timer, next_clock);
  11.     }
  12. }

正因为无论win7虚拟机如何配置参数，系统运行时始终会去触发rtc的ioport事件，也就是去读取rtc时钟源时间，且一旦我们不配置driftfix=slew，则win7的始终就不会得到补偿。因此，可以证明win7的始终时间是从rtc中获取的。这就是为什么win7时钟时间会在stop后得到补充了。

五、参考链接

1.内核timer架构简介 - 知乎

2. Linux系统的时间管理及优化_acpi tsc_孙飞 Sunface的博客-CSDN博客

不会写代码的小可爱&&
关注
专栏目录
qemu时钟
heron804的专栏
03-20 3507
QEMU有三种时钟：REALTIME、VIRTUAL和HOST时钟。 REALTIME时钟是通过直接获取宿主机CPU的时钟信息来计时。 VIRTUAL时钟在use_icount不为0时，通过模拟执行的指令数来计时；在use_icount为0时，本质上还是REALTIME时钟。 HOST时钟则是直接从宿主系统中获取实际信息。 在windows下，获取CPU始终频率使用下面方法：
QEMU-KVM基本原理
lingshengxiyou的博客
01-31 939
KVM是依赖于硬件辅助虚拟化技术的全虚拟化解决方案，其基本思想是在Linux内核的基础上添加虚拟机管理模块，重用Linux内核中已完善和成熟的机制和模块，比如进程调度、内存管理、IO管理等，使之成为一个可以支持运行虚拟机的hypervisor（虚拟机监控程序）。将虚拟机操作系统放在Ring1运行，它在执行特权指令时，会触发异常（CPU的机制，执行没权限的指令会触发异常），然后VMM捕获这个异常，在异常里面做翻译，模拟，最后返回到虚拟机操作系统内，虚拟机操作系统认为自己的特权指令能正常工作，继续运行。
Qemu(纯软实现)架构+KVM(基于kernel模拟硬件)原理(一)
2401_84411776的博客
05-04 774
其实客户端开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。然而Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。贵在坚持！《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可获取！天几夜就能学好的，必须养成平时努力学习的习惯。贵在坚持！
qemu 原理
深空深蓝的博客
08-27 1625
qemu http://archives.cse.iitd.ernet.in/~sbansal/csl862-virt/2010/readings/bellard.pdf https://www.slideshare.net/RampantJeff/qemu-binary-translation User mode emulation Run a Linux process compiled fo...
QEMU-KVM虚机动态迁移原理
weixin_33997389的博客
03-17 1024
在虚拟化领域，虚机动态迁移是一个非常有趣且持续不断的话题：因为随着使用需求，客户机变得越来越大（单个虚机的vCPU和RAM越来越多）且客户机正常运行不间断的需求也变得越来越严格。本次讨论将围绕QEMU/KVM hypervisor早期在线迁移的简单设计，例如到它是如何优化到当前的技术能力，未来将如何发展。这里会探讨在线迁移真正的工作原理，限制条件以及如何开发新思路设计来满足最...
Qemu-kvm
m0_65849838的博客
04-27 5121
文章目录一.KVM的原理简介1.KVM的工作流程2.KVM的架构3.KVM模块二.Qemu原理介绍1.Qemu架构.2.Qemu模块3.Qemu的三种运行模式4.Qemu的特点三.KVM和Qemu的关系四.Qemu工具介绍1.qemu-img2.qemu-img3.qemu-kvm4.qemu-kvm5.qemu-ga6，qemu-io7.qemu-nbd五.Qemu支持的磁盘格式介绍1.qemu-nbd 一.KVM的原理简介 1.KVM的工作流程 用户模式的qemu利用libkvm通过ioctl进入内核模
QEMU-KVM设备虚拟化研究与改进1
08-03
总的来说，这篇论文深入研究了QEMU-KVM的设备虚拟化，并提出了多项创新性的改进方案，包括时钟设备虚拟化、固定PCI设备I/O基地址、硬件管理器虚拟化和优化中断处理，对于提升虚拟机的性能和效率具有重要意义。...
qemu-kvm 线程事件模型 【QEMU-KVM代码分析之三】
tycoon的专栏
04-17 3024
qemu-kvm 线程事件模型 1.主（父）线程。 主线程执行循环，主要做三件事情 1）.执行select操作，查询文件描述符有无读写操作 2）.执行定时器回调函数 3）.执行下半部（BH）回调函数。为什么要采用BH，资料说主要避免可重入性和调用栈溢出。 2.执行客户机代码的线程 只讨论kvm执行客户机代码情况（不考虑TCG，TCG采用动态翻译技术），如果有多个vcpu，就意味着
qemu-kvm 中断虚拟化
tycoon的专栏
07-30 1753
写写中断的东西，但是还是有些地方不理解，希望大家多多指教。   中断，这个概念相信大家已经不陌生了，我也没什么资格来介绍中断，就简单的说一下。我认为它从宏观上看可以分为软件部分和硬件部分。 软件部分： 软件部分在操作系统中实现，如Linux中断的x86，每一个中断对应一个中断门，中断门中包含中断处理函数（ISR或者别的）地址，优先级等等。CPU可以通过LIDT加载这个描述符表，跳转到指定的
QEMU&KVM 虚拟机实例demo以及RISCV/x86上KVM的实现分析
tugouxp的专栏
05-02 2836
KVM通过一组IOCTL向用户空间导出接口，这些接口能够用于虚拟机的创建，虚拟机内存的设置，虚拟机VCPU的创建与运行等，按照接口所使用的文件描述符不同，KVM的这组IOCTL接口可以分为三类：0./dev/kvm节点对应全局kvmfd, 通过kvmfd创建每个虚拟机对应的vmfd, 再由vmfd为每个虚拟VCPU创建一个vcpufd,vcpufd通过vmfd暴露的接口获取。KVM全局管理用kvmfd，虚拟机管理用vmfd, vcpu运行用vcpufd. 内核对应三套chrdev的fops.
介绍QEMU 原理的文档资料
08-08
What is QEMU ? 简单文档，描述QEMU和原理图的。
qemu技术分析
01-08
详细描述当前最流行的cpu仿真器qemu核心技术：二进制动态翻译器的原理及实现
QEMU/KVM原理概述
rayylee
02-02 6368
1. QEMU与KVM 架构 qemu 和 kvm 架构整体上分为 3 部分，对应着上图的三个部分 (左上、右上和下)，3 部分分别是 VMX root 的应用层，VMX no-root 和 VMX root 的内核层（分别对应着左上、右上和下） VMX root: 宿主机根模式，CPU 在运行包括 QEMU 在内的普通进程和宿主机的操作系统内核时，CPU 处在该模式。 VMX no-root: 宿主机非根模式，CPU 在运行虚拟机中的用户程序和操作系统代码的时候处于 VMX no-root 模式 注：
Qemu(纯软实现)架构+KVM(基于kernel模拟硬件)原理(一)(1)
最新发布
2401_84412738的博客
05-12 641
QEMU是“Quick Emulator”的缩写，是一个用C语言编写的开源虚拟化软件。本文的目的是描述本人所理解的QEMU技术架构的见解，并以此抛砖引玉。众所周知，QEMU的源代码开发文档非常稀少，描述内部结构和工作机理的文档更是凤毛麟角，一般的开发人员想要从事QEMU的开发工作，通常只能从源代码入手。因此，对于技术人员来说，了解QEMU是一项艰巨的任务。QEMU有几种虚拟化模式。首先，它可以使用基于内核的虚拟机（KVM）执行x86处理器硬件虚拟化，以几乎比拟硬件本机的速度执行运算任务。其次，它可以通过机器
KVM-QEMU基本工作原理分析（二）
bob的博客
04-30 1972
1、理解KVM与Qemu的关系 我们都知道开源虚拟机KVM，并且知道它总是跟Qemu结合出现，那这两者之间有什么关系呢？ 首先，Qemu本身并不是KVM的一部分，而是一整套完整的虚拟化解决方案，它是纯软件实现的，包括处理器虚拟化、内存虚拟化以及各种虚拟设备的模拟，但因为是纯软件模拟，所以性能相对比较低。 而广义的KVM实际上包含两部分，一部分是基于LINUX内核支持的KVM内核模块，另一部分就是经...
Qemu-KVM基本工作原理分析
热门推荐
Mr.Buffoon
12-09 1万+
1、理解KVM与Qemu的关系       我们都知道开源虚拟机KVM，并且知道它总是跟Qemu结合出现，那这两者之间有什么关系呢？     首先，Qemu本身并不是KVM的一部分，而是一整套完整的虚拟化解决方案，它是纯软件实现的，包括处理器虚拟化、内存虚拟化以及各种虚拟设备的模拟，但因为是纯软件模拟，所以性能相对比较低。      而广义的KVM实际上包含两部分，一部分是基于LINUX内
qemu-kvm未找到命令
05-19
如果你在使用 Linux 操作系统，那么 qemu-kvm 命令可能没有安装或者没有加入 PATH 环境变量中。你可以通过以下步骤来解决这个问题： 1. 检查 qemu-kvm 是否已经安装：在终端中输入以下命令： ``` qemu-kvm --version ``` 如果该命令返回 qemu-kvm 的版本信息，那么说明 qemu-kvm 已经安装成功了。 2. 如果该命令返回 "command not found" 或者 "未找到命令" 的错误信息，则说明 qemu-kvm 没有安装或者没有加入 PATH 环境变量中。 3. 如果 qemu-kvm 没有安装，那么你需要安装 qemu-kvm。在大部分 Linux 发行版中，你可以使用以下命令来安装 qemu-kvm： ``` sudo apt-get install qemu-kvm ``` 注意：不同的 Linux 发行版可能有不同的安装方式，请根据你的发行版文档来进行安装。 4. 如果 qemu-kvm 已经安装，但是没有加入 PATH 环境变量中，你需要手动将 qemu-kvm 的路径添加到 PATH 环境变量中。在终端中输入以下命令： ``` export PATH=$PATH:/usr/bin/qemu-kvm ``` 注意：如果你的 qemu-kvm 安装路径不同，请将上面命令中的 "/usr/bin/qemu-kvm" 替换为你的 qemu-kvm 安装路径。 完成上述步骤后，你应该可以在终端中使用 qemu-kvm 命令了。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不会写代码的小可爱&&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值