kvm虚拟化 steal time 机制详解

2024-01-06 23:52
文章标签 详解 机制 虚拟化 time kvm steal

本文主要是介绍kvm虚拟化 steal time 机制详解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

        • 1 steal time 机制介绍
        • 2 guest os 中 steal time 初始化流程
        • 3 guest os 使用 steal time
        • 5 host os steal time 时间记录与更新

1 steal time 机制介绍

steal time 是指在虚拟化的环境下，管理机（host os，如 linux）窃取的虚拟机中的时间（虚拟机上的一个 vcpu 对应主机上一个线程，当该线程未在运行时，则是主机窃取的虚机时间），即 vcpu 没有在运行的时间。

在虚机中执行 top 命令，其中有一个 st 字段，该字段数据则是描述主机窃取时间占比的。
ps：对于真实物理机器：该字段永远为 0，如果是 guest os：该字段可能不为0，如果该字段占比较大，说明主机任务比较繁忙，该虚机被调度较少。
st 数据可以让 guest 看到自己真正占用的 cpu 时间比例。，如果 st 值较高，则说明主机窃取时间多，主机管理端繁忙。

要支持 steal time 机制，需要内核启用 CONFIG_PARAVIRT 半虚拟化配置，这样内核可以在运行时检测自己处于虚拟机状态。

（下面的讲解都以 x86 的硬件支持为例）
steal time 机制又由 MSR_KVM_STEAL_TIME 特性支持，虚拟机可以通过读取特定字段来判断自己在虚机中是否支持 steal time 特性。该特性由下面的数据结构实现支持：

#define MSR_KVM_STEAL_TIME  0x4b564d03struct kvm_steal_time {__u64 steal;__u32 version;__u32 flags;__u8  preempted;__u8  u8_pad[3];__u32 pad[11];
};主机管理机定期更新填充该数据结构，每个 vcpu 只需要一次写操作或注册。
此结构更新间隔不固定，根据任务调度，出对入队等信息不定时更新。
主机会在上述任意时刻更新该结构，直到写入 0，则禁用该功能。
version 是一个序列计数器，虚机在读取该结构数据之前和之后需要检查该字段，
并且确保前后两者值相等，并且为偶数，如果为奇数则说明正在更新，需要重新获取。
flags 目前未使用，将来将会用来表示该结构的变化。
steal 记录该 vcpu 未运行的时间，以纳秒为单位。
preempted 记录该 vcpu 抢占状态以及其他一些信息，包括 vcpu 未运行，tlb flush op。
其他字段为填充字段，将来用于拓展。
2 guest os 中 steal time 初始化流程

一些补充：
为什么 guest os （linux）需要去检测自己是否处于虚拟化环境？
linux 启动中可以检测自己处于虚拟化环境运行，这一步是有意义的，知道自己处于虚拟化环境，那么许多操作可以基于虚拟化进行优化，替换原有的默认操作，以此提高性能或者相关安全性，比如 steal time 机制可以替换 clock 相关接口，用于记录被管理机窃取的运行时间，从而重新计算任务的调度时间片，使其虚机上运行的任务得到真实的运行时间。
又比如 tlb flush 操作可以替换为 kvm 的特定 tlb flush 操作，以提高刷新 flush 的性能，这在实际应用中性能提高非常明显。

当 guestOS 启动时，有如下路径（注意：该流程为 guest OS （linux）的初始化流程）：

setup_arch-> init_hypervisor_platform-> x86_init.hyper.guest_late_init();当系统启动时 guest_late_init 拥有如下默认值：
struct x86_init_ops x86_init __initdata = {
....hyper = {.init_platform		= x86_init_noop,.guest_late_init	= x86_init_noop,.x2apic_available	= bool_x86_init_noop,.init_mem_mapping	= x86_init_noop,.init_after_bootmem	= x86_init_noop,},
...
void x86_init_noop(void) { }即 x86_init.hyper.guest_late_init() 操作为空，但是在之前还有一个 init_hypervisor_platform。
它将检测到自己正处于虚机运行状态，此时在支持了半虚拟化下则会将许多默认接口替换为虚拟化接口。
void __init init_hypervisor_platform(void)
{const struct hypervisor_x86 *h;h = detect_hypervisor_vendor();if (!h)return;// 如果检测出 h 有值，则是虚机运行，将虚机使用的回调替换到默认回调中。copy_array(&h->init, &x86_init.hyper, sizeof(h->init));copy_array(&h->runtime, &x86_platform.hyper, sizeof(h->runtime));x86_hyper_type = h->type;x86_init.hyper.init_platform();
}static inline const struct hypervisor_x86 * __init
detect_hypervisor_vendor(void)
{const struct hypervisor_x86 *h = NULL, * const *p;uint32_t pri, max_pri = 0;// 遍历所有可能的虚拟化支持，并执行 detectfor (p = hypervisors; p < hypervisors + ARRAY_SIZE(hypervisors); p++) {pri = (*p)->detect();if (pri > max_pri) {max_pri = pri;h = *p;}}if (h)pr_info("Hypervisor detected: %s\n", h->name);return h;
}static const __initconst struct hypervisor_x86 * const hypervisors[] =
{
#ifdef CONFIG_XEN_PV&x86_hyper_xen_pv,
#endif
#ifdef CONFIG_XEN_PVHVM&x86_hyper_xen_hvm,
#endif&x86_hyper_vmware,&x86_hyper_ms_hyperv,
#ifdef CONFIG_KVM_GUEST&x86_hyper_kvm,
#endif
#ifdef CONFIG_JAILHOUSE_GUEST&x86_hyper_jailhouse,
#endif
};// 对于 kvm 有如下
const __initconst struct hypervisor_x86 x86_hyper_kvm = {.name			= "KVM",.detect			= kvm_detect,.type			= X86_HYPER_KVM,.init.guest_late_init	= kvm_guest_init,.init.x2apic_available	= kvm_para_available,.init.init_platform	= kvm_init_platform,
};kvm_detect-> kvm_cpuid_base-> __kvm_cpuid_base// 通过读取 cpuid 字段，得到 KVMKVMKVM 则说明是 kvm 虚拟化运行。
static noinline uint32_t __kvm_cpuid_base(void)
{if (boot_cpu_data.cpuid_level < 0)return 0;	/* So we don't blow up on old processors */if (boot_cpu_has(X86_FEATURE_HYPERVISOR))return hypervisor_cpuid_base("KVMKVMKVM\0\0\0", 0);return 0;
}那么到这里，一个 guestOS 则会最终调用 kvm_guest_init，做 kvm 虚拟化的初始化：
static void __init kvm_guest_init(void)
{
...if (kvm_para_has_feature(KVM_FEATURE_STEAL_TIME)) {has_steal_clock = 1;pv_time_ops.steal_clock = kvm_steal_clock;}if (kvm_para_has_feature(KVM_FEATURE_PV_TLB_FLUSH) &&!kvm_para_has_hint(KVM_HINTS_REALTIME) &&kvm_para_has_feature(KVM_FEATURE_STEAL_TIME)) {pv_mmu_ops.flush_tlb_others = kvm_flush_tlb_others;pv_mmu_ops.tlb_remove_table = tlb_remove_table;}
...
}
可以看到 pv_time_ops.steal_clock 为 kvm_steal_clock，
pv_mmu_ops.flush_tlb_others 也被替换为了 kvm_flush_tlb_others。接着在每个cpu的路径上会调用到 kvm_guest_cpu_init：
static void kvm_guest_cpu_init(void)
{
...if (has_steal_clock)kvm_register_steal_time();
}static DEFINE_PER_CPU_DECRYPTED(struct kvm_steal_time, steal_time) __aligned(64);// 每个 vcpu 都会将该全局的 percpu 变量的物理地址写入到 msr 虚拟寄存器中。
static void kvm_register_steal_time(void)
{int cpu = smp_processor_id();struct kvm_steal_time *st = &per_cpu(steal_time, cpu);if (!has_steal_clock)return;wrmsrl(MSR_KVM_STEAL_TIME, (slow_virt_to_phys(st) | KVM_MSR_ENABLED));pr_info("kvm-stealtime: cpu %d, msr %llx\n",cpu, (unsigned long long) slow_virt_to_phys(st));
}注意这里是虚机运行，当写 msr 时会触发异常退出到 host，在 vcpu 退出时将检测退出原因：
如是 vmx 则是下面，如果是仿真，则是其他路径：
vmx_handle_exit-> kvm_vmx_exit_handlers[exit_reason](vcpu);
static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
...[EXIT_REASON_MSR_WRITE]               = handle_wrmsr,
...
}handle_wrmsr-> kvm_set_msrcase MSR_KVM_STEAL_TIME:if (unlikely(!sched_info_on()))return 1;if (data & KVM_STEAL_RESERVED_MASK)return 1;if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.st.stime,data & KVM_STEAL_VALID_BITS,sizeof(struct kvm_steal_time)))return 1;vcpu->arch.st.msr_val = data;if (!(data & KVM_MSR_ENABLED))break;kvm_make_request(KVM_REQ_STEAL_UPDATE, vcpu);break;可以看到对应的 vcpu 中 msr 写的物理地址（gpa）将会被写入到 host 的 cpu->arch.st.stime 中，
这样即可建立主机与 guest 对应内存的访问方式。
3 guest os 使用 steal time

首先是：

pv_time_ops.steal_clock = kvm_steal_clock;static u64 kvm_steal_clock(int cpu)
{u64 steal;struct kvm_steal_time *src;int version;src = &per_cpu(steal_time, cpu);do {version = src->version;virt_rmb();steal = src->steal;virt_rmb();} while ((version & 1) || (version != src->version));return steal;
}static inline u64 paravirt_steal_clock(int cpu)
{return PVOP_CALL1(u64, pv_time_ops.steal_clock, cpu);
}

虚机通过读取 &per_cpu(steal_time)->steal 获取到主机窃取的 vcpu 时间。

主要在两个地方使用：

paravirt_steal_clock-> steal_account_process_time-> update_rq_clock_task(1)steal_account_process_time
该接口主要看一下 account_process_tick
account_process_tick-> update_process_times-> tick_sched_handle
在某些定时器中将会更新该值：
static __always_inline u64 steal_account_process_time(u64 maxtime)
{
#ifdef CONFIG_PARAVIRTif (static_key_false(&paravirt_steal_enabled)) {u64 steal;// 通过 paravirt_steal_clock 获取当前 cpu 的 steal time，// 减去上次的 prev_steal_time，那么就是该期间的 steal time，// 该 steal 将会被累加到 cpustat[CPUTIME_STEAL] += cputime; 中，// 应用程序将会在 top 看到该值的计算结果。// 另外会返回该期间的 steal，并且更新 prev_steal_time 为当前 steal time。steal = paravirt_steal_clock(smp_processor_id());steal -= this_rq()->prev_steal_time;steal = min(steal, maxtime);account_steal_time(steal);this_rq()->prev_steal_time += steal;return steal;}
#endifreturn 0;
}// 计算系统时间时，steal_account_process_time 将会返回系统被窃取的时间，
// 并从实际时间中减去该部分，得到虚机系统真实的运行时间，
// 对于 host 系统来说，steal 等于 0。
void account_process_tick(struct task_struct *p, int user_tick)
{
...steal = steal_account_process_time(ULONG_MAX);if (steal >= cputime)return;cputime -= steal;if (user_tick)account_user_time(p, cputime);else if ((p != rq->idle) || (irq_count() != HARDIRQ_OFFSET))account_system_time(p, HARDIRQ_OFFSET, cputime);elseaccount_idle_time(cputime);
}（2）update_rq_clock_task
update_rq_clock_task-> update_rq_clock
该处处于系统调度的重要使用函数，在任意需要更新调度时间的地方均会调用 update_rq_clock_task。
static void update_rq_clock_task(struct rq *rq, s64 delta)
{
...
#ifdef CONFIG_PARAVIRT_TIME_ACCOUNTINGif (static_key_false((&paravirt_steal_rq_enabled))) {// 获取到当前 cpu 系统的窃取时间，并减去上次记录的时间，// 得到在此期间被窃取的时间，将系统实际运行的时间片减去窃取窃取部分的，// 那么就会得到系统真实的运行时间，并且将当前窃取时间累加到 prev_steal_time_rq，// 方便后续计算。steal = paravirt_steal_clock(cpu_of(rq));steal -= rq->prev_steal_time_rq;if (unlikely(steal > delta))steal = delta;rq->prev_steal_time_rq += steal;delta -= steal;}
#endifrq->clock_task += delta;#ifdef CONFIG_HAVE_SCHED_AVG_IRQif ((irq_delta + steal) && sched_feat(NONTASK_CAPACITY))update_irq_load_avg(rq, irq_delta + steal);
#endif

从上可以看到，通过在关键路径计算中减去 steal time的时间，得到虚机实际的运行时间，通过这种方式，虚机内部就可以感知到被窃取的时间，并通过计算将窃取时间从实际时间中移除，得到系统真实的运行时间。

5 host os steal time 时间记录与更新

前面看到的都是 guest os 如何使用 steal time 时间，那么该部分时间从哪里来的呢？
steal time 时间则是由 host os 来负载记录与更新。

通过启动流程可以知道，percpu 的 steal time 的物理地址通过 msr 已经传递给了 host 主机，由 host 在合适的时机去更新 steal time，具体位置在前面分析的 record_steal_time 中，每当 vcpu 即将开始运行时，都会更新 steal time 时间，让虚机得到真实的窃取时间。

static void record_steal_time(struct kvm_vcpu *vcpu)
{if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED))return;// 通过 write msr，vcpu->arch.st.stime 已经被初始化，保存了虚机内部 stiem percpu// 的物理地址，通过 kvm memslot 机制可以将其 gpa 地址转换为 hva 主机端虚拟地址。// 并将其对应的 steal time 结构体数据读取到主机端的 vcpu->arch.st.steal 中。if (unlikely(kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,&vcpu->arch.st.steal, sizeof(struct kvm_steal_time))))return;/** Doing a TLB flush here, on the guest's behalf, can avoid* expensive IPIs.*/if (xchg(&vcpu->arch.st.steal.preempted, 0) & KVM_VCPU_FLUSH_TLB)kvm_vcpu_flush_tlb(vcpu, false);// 保证处于偶数if (vcpu->arch.st.steal.version & 1)vcpu->arch.st.steal.version += 1;  /* first time write, random junk */// 设置为奇数，表示主机正在更新该值，虚机会在检测到奇数时重新读取，直到为偶数。vcpu->arch.st.steal.version += 1;kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));smp_wmb();// 将 current 的 run_delay 累加到 steal 中，// run_delay 表示当前任务未在运行的时间，即包括不在 rq 队列上和在 rq 队列上等待的时间。vcpu->arch.st.steal.steal += current->sched_info.run_delay -vcpu->arch.st.last_steal;// 将 last_steal 更新为当前的 run_delay，方便下一次计算。vcpu->arch.st.last_steal = current->sched_info.run_delay;kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));smp_wmb();// 完成更新后，将 version 设置为偶数，虚机可以读取了。vcpu->arch.st.steal.version += 1;kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
}

通过 record_steal_time，虚机内部的 steal time 会被更新为当前 vcpu 最新的被窃取时间。

run_delay 如何计算的呢？如下：

sched_info_dequeued
​	-> dequeue_task（设置 cpumask，迁移task，设置优先级）sched_info_arrive
​	-> __sched_info_switch
​		-> sched_info_switch
​			-> prepare_task_switchsched_info_queued
​	-> enqueue_task
​	-> sched_info_depart
​	-> __sched_info_switch (prev)

所有的计算是在 schedule 中计算的：

schedule-> __schedule-> context_switch-> prepare_task_switch(rq, prev, next);-> sched_info_switch(rq, prev, next);-> __sched_info_switchstatic inline void
__sched_info_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next)
{/** prev now departs the CPU.  It's not interesting to record* stats about how efficient we were at scheduling the idle* process, however.*/if (prev != rq->idle)sched_info_depart(rq, prev);if (next != rq->idle)sched_info_arrive(rq, next);
}(1)首先看看 sched_info_depart
static inline void sched_info_depart(struct rq *rq, struct task_struct *t)
{unsigned long long delta = rq_clock(rq) - t->sched_info.last_arrival;rq_sched_info_depart(rq, delta);if (t->state == TASK_RUNNING)sched_info_queued(rq, t);
}static inline void sched_info_queued(struct rq *rq, struct task_struct *t)
{// 首先这里记录的是上一个任务的退出时间保存在 sched_info.last_queued 中。if (unlikely(sched_info_on())) {if (!t->sched_info.last_queued)t->sched_info.last_queued = rq_clock(rq);}
}static void sched_info_arrive(struct rq *rq, struct task_struct *t)
{unsigned long long now = rq_clock(rq), delta = 0;if (t->sched_info.last_queued)delta = now - t->sched_info.last_queued;sched_info_reset_dequeued(t);t->sched_info.run_delay += delta;t->sched_info.last_arrival = now;t->sched_info.pcount++;rq_sched_info_arrive(rq, delta);
}

当任务进行切换时，在 __sched_info_switch 中将会处理 run_delay 的计算。

sched_info_depart 计算的是 prev task 的时间，上一个任务即将被调度出去，将该点时间记录到 last_queued 中。

sched_info_arrive 计算的是 next task 的时间，该任务即将开始运行，将现在时间减去 sched_info.last_queued 时间，得到 run_delay 时间，因为 sched_info.last_queued 记录的是上一次调度出去的时间，所以这一次相减即可得到 run_delay，接着将其累加到 t->sched_info.run_delay 中，并更新 sched_info.last_arrival 为 now，方便下一次计算。

上述代码可以总结出：每当任务被调度出去之前记录当前时间last_queued，每当任务开始运行时，将当前时间减去上一次的 last_queued 得到 run_dealy，就是任务没有运行的时间。

这篇关于kvm虚拟化 steal time 机制详解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/578046。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息，即可快速实现设备配网，是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递，利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后，即可发送相关配网数据。同时还支持与常规Sof
阅读更多...
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）

上篇：6.1.数据结构-c/c++模拟实现堆上篇（向下，上调整算法，建堆，增删数据）-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小)： 2.2 C语言代码（手写堆） 2.3 C++代码（使用优先级队列 priority_queue）
阅读更多...
Java ArrayList扩容机制 （源码解读）

Java ArrayList扩容机制 （源码解读）

结论：初始长度为10，若所需长度小于1.5倍原长度，则按照1.5倍扩容。若不够用则按照所需长度扩容。 一. 明确类内部重要变量含义         1：数组默认长度         2:这是一个共享的空数组实例，用于明确创建长度为0时的ArrayList ，比如通过 new ArrayList<>(0)，ArrayList 内部的数组 elementData 会指向这个 EMPTY_EL
阅读更多...
K8S（Kubernetes）开源的容器编排平台安装步骤详解

K8S（Kubernetes）开源的容器编排平台安装步骤详解

K8S（Kubernetes）是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。以下是K8S容器编排平台的安装步骤、使用方式及特点的概述： 安装步骤： 安装Docker：K8S需要基于Docker来运行容器化应用程序。首先要在所有节点上安装Docker引擎。 安装Kubernetes Master：在集群中选择一台主机作为Master节点，安装K8S的控制平面组件，如AP
阅读更多...
【编程底层思考】垃圾收集机制，GC算法，垃圾收集器类型概述

【编程底层思考】垃圾收集机制，GC算法，垃圾收集器类型概述

Java的垃圾收集（Garbage Collection，GC）机制是Java语言的一大特色，它负责自动管理内存的回收，释放不再使用的对象所占用的内存。以下是对Java垃圾收集机制的详细介绍： 一、垃圾收集机制概述： 对象存活判断：垃圾收集器定期检查堆内存中的对象，判断哪些对象是“垃圾”，即不再被任何引用链直接或间接引用的对象。内存回收：将判断为垃圾的对象占用的内存进行回收，以便重新使用。
阅读更多...
【Tools】大模型中的自注意力机制

【Tools】大模型中的自注意力机制

摇来摇去摇碎点点的金黄 伸手牵来一片梦的霞光 南方的小巷推开多情的门窗 年轻和我们歌唱 摇来摇去摇着温柔的阳光 轻轻托起一件梦的衣裳 古老的都市每天都改变模样                      🎵 方芳《摇太阳》 自注意力机制（Self-Attention）是一种在Transformer等大模型中经常使用的注意力机制。该机制通过对输入序列中的每个元素计算与其他元素之间的相似性，
阅读更多...
如何通俗理解注意力机制？

如何通俗理解注意力机制？

1、注意力机制（Attention Mechanism）是机器学习和深度学习中一种模拟人类注意力的方法，用于提高模型在处理大量信息时的效率和效果。通俗地理解，它就像是在一堆信息中找到最重要的部分，把注意力集中在这些关键点上，从而更好地完成任务。以下是几个简单的比喻来帮助理解注意力机制： 2、寻找重点：想象一下，你在阅读一篇文章的时候，有些段落特别重要，你会特别注意这些段落，反复阅读，而对其他部分
阅读更多...
嵌入式Openharmony系统构建与启动详解

嵌入式Openharmony系统构建与启动详解

大家好，今天主要给大家分享一下，如何构建Openharmony子系统以及系统的启动过程分解。 第一：OpenHarmony系统构建      首先熟悉一下，构建系统是一种自动化处理工具的集合，通过将源代码文件进行一系列处理，最终生成和用户可以使用的目标文件。这里的目标文件包括静态链接库文件、动态链接库文件、可执行文件、脚本文件、配置文件等。      我们在编写hellowor
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2