QEMU源码全解析 —— CPU虚拟化（17）

已于 2024-08-01 13:44:16 修改
阅读量363 收藏
点赞数 8
分类专栏： QEMU/KVM 文章标签： QEMU KVM CPU虚拟化
于 2024-08-01 10:54:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/phmatthaus/article/details/140827225
版权
QEMU/KVM 专栏收录该内容
123 篇文章 36 订阅 ¥49.90 ¥99.00
已订阅 8折续费
您已是超级会员，正在免费阅读会员专享内容
查看更多超级会员权益

接前一篇文章：

本文内容参考：

《趣谈 Linux操作系统 》 —— 刘超， 极客时间

《 QEMU /KVM》 源码 解析与应用 —— 李强，机械工业出版社

《深度探索 Linux 系统 虚拟化 原理与实现》—— 王柏生 谢广军， 机械工业出版社

特此致谢！

三、KVM模块初始化介绍

2. KVM模块初始化

上一回开始对于kvm_init函数进行解析。讲解了第1个函数kvm_arch_init。本回继续往下进行讲解。为了便于理解和回顾，再次贴出kvm_init的源码，在Linux内核源码根目录/virt/kvm/kvm_main.c中，代码如下： 

  1. int kvm_init(void *opaque, unsigned vcpu_size, unsigned vcpu_align,
  2. 		  struct module *module)
  3. {
  4. 	struct kvm_cpu_compat_check c;
  5. 	int r;
  6. 	int cpu;
  7.  
  8. 	r = kvm_arch_init(opaque);
  9. 	if (r)
  10. 		goto out_fail;
  11.  
  12. 	/*
  13. 	 * kvm_arch_init makes sure there's at most one caller
  14. 	 * for architectures that support multiple implementations,
  15. 	 * like intel and amd on x86.
  16. 	 * kvm_arch_init must be called before kvm_irqfd_init to avoid creating
  17. 	 * conflicts in case kvm is already setup for another implementation.
  18. 	 */
  19. 	r = kvm_irqfd_init();
  20. 	if (r)
  21. 		goto out_irqfd;
  22.  
  23. 	if (!zalloc_cpumask_var(&cpus_hardware_enabled, GFP_KERNEL)) {
  24. 		r = -ENOMEM;
  25. 		goto out_free_0;
  26. 	}
  27.  
  28. 	r = kvm_arch_hardware_setup(opaque);
  29. 	if (r < 0)
  30. 		goto out_free_1;
  31.  
  32. 	c.ret = &r;
  33. 	c.opaque = opaque;
  34. 	for_each_online_cpu(cpu) {
  35. 		smp_call_function_single(cpu, check_processor_compat, &c, 1);
  36. 		if (r < 0)
  37. 			goto out_free_2;
  38. 	}
  39.  
  40. 	r = cpuhp_setup_state_nocalls(CPUHP_AP_KVM_STARTING, "kvm/cpu:starting",
  41. 				      kvm_starting_cpu, kvm_dying_cpu);
  42. 	if (r)
  43. 		goto out_free_2;
  44. 	register_reboot_notifier(&kvm_reboot_notifier);
  45.  
  46. 	/* A kmem cache lets us meet the alignment requirements of fx_save. */
  47. 	if (!vcpu_align)
  48. 		vcpu_align = __alignof__(struct kvm_vcpu);
  49. 	kvm_vcpu_cache =
  50. 		kmem_cache_create_usercopy("kvm_vcpu", vcpu_size, vcpu_align,
  51. 					   SLAB_ACCOUNT,
  52. 					   offsetof(struct kvm_vcpu, arch),
  53. 					   offsetofend(struct kvm_vcpu, stats_id)
  54. 					   - offsetof(struct kvm_vcpu, arch),
  55. 					   NULL);
  56. 	if (!kvm_vcpu_cache) {
  57. 		r = -ENOMEM;
  58. 		goto out_free_3;
  59. 	}
  60.  
  61. 	for_each_possible_cpu(cpu) {
  62. 		if (!alloc_cpumask_var_node(&per_cpu(cpu_kick_mask, cpu),
  63. 					    GFP_KERNEL, cpu_to_node(cpu))) {
  64. 			r = -ENOMEM;
  65. 			goto out_free_4;
  66. 		}
  67. 	}
  68.  
  69. 	r = kvm_async_pf_init();
  70. 	if (r)
  71. 		goto out_free_4;
  72.  
  73. 	kvm_chardev_ops.owner = module;
  74.  
  75. 	r = misc_register(&kvm_dev);
  76. 	if (r) {
  77. 		pr_err("kvm: misc device register failed\n");
  78. 		goto out_unreg;
  79. 	}
  80.  
  81. 	register_syscore_ops(&kvm_syscore_ops);
  82.  
  83. 	kvm_preempt_ops.sched_in = kvm_sched_in;
  84. 	kvm_preempt_ops.sched_out = kvm_sched_out;
  85.  
  86. 	kvm_init_debug();
  87.  
  88. 	r = kvm_vfio_ops_init();
  89. 	WARN_ON(r);
  90.  
  91. 	return 0;
  92.  
  93. out_unreg:
  94. 	kvm_async_pf_deinit();
  95. out_free_4:
  96. 	for_each_possible_cpu(cpu)
  97. 		free_cpumask_var(per_cpu(cpu_kick_mask, cpu));
  98. 	kmem_cache_destroy(kvm_vcpu_cache);
  99. out_free_3:
  100. 	unregister_reboot_notifier(&kvm_reboot_notifier);
  101. 	cpuhp_remove_state_nocalls(CPUHP_AP_KVM_STARTING);
  102. out_free_2:
  103. 	kvm_arch_hardware_unsetup();
  104. out_free_1:
  105. 	free_cpumask_var(cpus_hardware_enabled);
  106. out_free_0:
  107. 	kvm_irqfd_exit();
  108. out_irqfd:
  109. 	kvm_arch_exit();
  110. out_fail:
  111. 	return r;
  112. }
  113. EXPORT_SYMBOL_GPL(kvm_init);

kvm_init函数总体调用的函数如下图所示：

（2）kvm_irqfd_init函数

代码片段如下： 

  1. 	/*
  2. 	 * kvm_arch_init makes sure there's at most one caller
  3. 	 * for architectures that support multiple implementations,
  4. 	 * like intel and amd on x86.
  5. 	 * kvm_arch_init must be called before kvm_irqfd_init to avoid creating
  6. 	 * conflicts in case kvm is already setup for another implementation.
  7. 	 */
  8. 	r = kvm_irqfd_init();
  9. 	if (r)
  10. 		goto out_irqfd;

该函数相关的声明在Linux内核源码根目录/include/linux/kvm_host.h中，如下： 

  1. #ifdef CONFIG_HAVE_KVM_IRQFD
  2. int kvm_irqfd_init(void);
  3. void kvm_irqfd_exit(void);
  4. #else
  5. static inline int kvm_irqfd_init(void)
  6. {
  7. 	return 0;
  8. }
  9.  
  10. static inline void kvm_irqfd_exit(void)
  11. {
  12. }
  13. #endif

可以看到，这是一个可以配置的函数。只有当配置了CONFIG_HAVE_KVM_IRQFD时，该函数才有实际内容，否则就是一个空函数。

配置有效的kvm_irqfd_init函数在Linux内核源码根目录/virt/kvm/eventfd.c中，代码如下： 

  1. /*
  2.  * create a host-wide workqueue for issuing deferred shutdown requests
  3.  * aggregated from all vm* instances. We need our own isolated
  4.  * queue to ease flushing work items when a VM exits.
  5.  */
  6. int kvm_irqfd_init(void)
  7. {
  8. 	irqfd_cleanup_wq = alloc_workqueue("kvm-irqfd-cleanup", 0, 0);
  9. 	if (!irqfd_cleanup_wq)
  10. 		return -ENOMEM;
  11.  
  12. 	return 0;
  13. }
  14.  
  15. void kvm_irqfd_exit(void)
  16. {
  17. 	destroy_workqueue(irqfd_cleanup_wq);
  18. }

这里要讲解一下QEMU/KVM的irqfd机制。参考以下博文：

https://www.cnblogs.com/haiyonghao/p/14440723.html

QEMU/KVM的irqfd机制

irqfd机制与ioeventfd机制类似，其基本原理都是基于eventfd。ioeventfd机制为Guest提供了向QEMU/KVM发送通知的快捷通道（Guest -> QEMU/KVM）；对应地，irqfd机制提供了QEMU/KVM向Guest发送通知的快捷通道（QEMU/KVM -> Guest）。

irqfd机制将一个eventfd与一个全局中断号联系起来，当向这个eventfd发送信号时，就会导致对应的中断注入到 虚拟机 中。

QEMU注册irqfd

与ioeventfd类似，irqfd在使用前必须先初始化一个EventNotifier对象（利用event_notifier_init函数初始化），初始化EventNotifier对象完成之后获得了一个eventfd。

向kvm发送注册中断irqfd请求

获得一个eventfd之后，QEMU通过kvm_irqchip_add_irqfd_notifier_gsi=>kvm_irqchip_assign_irqfd构造kvm_irqchip结构，并向kvm发送ioctl(KVM_IRQFD)。 

  1. static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int rfd, int virq,
  2.                                     bool assign)
  3. {
  4.     struct kvm_irqfd irqfd = {
  5.         .fd = fd,
  6.         .gsi = virq,
  7.         .flags = assign ? 0 : KVM_IRQFD_FLAG_DEASSIGN,
  8.     };
  9.  
  10.     if (rfd != -1) {
  11.         irqfd.flags |= KVM_IRQFD_FLAG_RESAMPLE;
  12.         irqfd.resamplefd = rfd;
  13.     }
  14.  
  15.     if (!kvm_irqfds_enabled()) {
  16.         return -ENOSYS;
  17.     }
  18.  
  19.     return kvm_vm_ioctl(s, KVM_IRQFD, &irqfd);
  20. }

在kvm_irqchip_assign_irqfd函数中，首先构造了一个kvm_irqfd结构的变量irqfd，其中fd为之前初始化的eventfd，gsi是全局系统中断，flags中定义了是向kvm注册irqfd（flags=0）还是解除注册irqfd（KVM_IRQFD_FLAG_DEASSIGN）（也就是flags=1）。flags的bit1（KVM_IRQFD_FLAG_RESAMPLE）表明该中断是否为电平触发。

  • KVM_IRQFD_FLAG_RESAMPLE相关信息

当中断处于沿触发模式时，irqfd->fd连接kvm中的中断芯片（irqchip）的gsi管脚，也由irqfd->fd负责中断的toggle，以及对用户空间的handler的触发。

当中断处于电平触发模式时，同样irqfd->fd连接kvm中的中断芯片的gsi管脚，当中断芯片收到一个EOI（end of interrupt）重采样信号时，gsi进行电平翻转，对用户空间的通知由irqfd->resample_fd完成（resample_fd也是一个eventfd）。

kvm_irqchip_assign_irqfd最后调用kvm_vm_ioctl(s, KVM_IRQFD, &irqfd)，向kvm请求注册包含上面构造的kvm_irqfd信息的irqfd。

kvm注册irqfd

收到ioctl(KVM_IRQFD)之后，KVM首先获取传入的数据结构kvm_irqfd的信息，然后调用kvm_irqfd函数。 

  1.     case KVM_IRQFD: {
  2. 		struct kvm_irqfd data;
  3.  
  4. 		r = -EFAULT;
  5. 		if (copy_from_user(&data, argp, sizeof(data)))
  6. 			goto out;
  7. 		r = kvm_irqfd(kvm, &data);
  8. 		break;
  9. 	}

在kvm_irqfd函数中，首先分辨传入的kvm_irqfd结构中的flags的bit0要求的是进行irqfd注册还是解除irqfd的注册。irqfd注册调用kvm_irqfd_assign函数；解除注册都调用kvm_irqfd_deasign函数。 

  1. int
  2. kvm_irqfd(struct kvm *kvm, struct kvm_irqfd *args)
  3. {
  4. 	if (args->flags & ~(KVM_IRQFD_FLAG_DEASSIGN | KVM_IRQFD_FLAG_RESAMPLE))
  5. 		return -EINVAL;
  6.  
  7. 	if (args->flags & KVM_IRQFD_FLAG_DEASSIGN)
  8. 		return kvm_irqfd_deassign(kvm, args);
  9.  
  10. 	return kvm_irqfd_assign(kvm, args);
  11. }

kvm_irqfd_assign函数在同文件（Linux内核源码根目录/virt/kvm/eventfd.c）中，代码如下： 

  1. static int
  2. kvm_irqfd_assign(struct kvm *kvm, struct kvm_irqfd *args)
  3. {
  4. 	struct kvm_kernel_irqfd *irqfd, *tmp;
  5. 	struct fd f;
  6. 	struct eventfd_ctx *eventfd = NULL, *resamplefd = NULL;
  7. 	int ret;
  8. 	__poll_t events;
  9. 	int idx;
  10.  
  11. 	if (!kvm_arch_intc_initialized(kvm))
  12. 		return -EAGAIN;
  13.  
  14. 	if (!kvm_arch_irqfd_allowed(kvm, args))
  15. 		return -EINVAL;
  16.  
  17. 	irqfd = kzalloc(sizeof(*irqfd), GFP_KERNEL_ACCOUNT);
  18. 	if (!irqfd)
  19. 		return -ENOMEM;
  20.  
  21. 	irqfd->kvm = kvm;
  22. 	irqfd->gsi = args->gsi;
  23. 	INIT_LIST_HEAD(&irqfd->list);
  24. 	INIT_WORK(&irqfd->inject, irqfd_inject);
  25. 	INIT_WORK(&irqfd->shutdown, irqfd_shutdown);
  26. 	seqcount_spinlock_init(&irqfd->irq_entry_sc, &kvm->irqfds.lock);
  27.  
  28. 	f = fdget(args->fd);
  29. 	if (!f.file) {
  30. 		ret = -EBADF;
  31. 		goto out;
  32. 	}
  33.  
  34. 	eventfd = eventfd_ctx_fileget(f.file);
  35. 	if (IS_ERR(eventfd)) {
  36. 		ret = PTR_ERR(eventfd);
  37. 		goto fail;
  38. 	}
  39.  
  40. 	irqfd->eventfd = eventfd;
  41.  
  42. 	if (args->flags & KVM_IRQFD_FLAG_RESAMPLE) {
  43. 		struct kvm_kernel_irqfd_resampler *resampler;
  44.  
  45. 		resamplefd = eventfd_ctx_fdget(args->resamplefd);
  46. 		if (IS_ERR(resamplefd)) {
  47. 			ret = PTR_ERR(resamplefd);
  48. 			goto fail;
  49. 		}
  50.  
  51. 		irqfd->resamplefd = resamplefd;
  52. 		INIT_LIST_HEAD(&irqfd->resampler_link);
  53.  
  54. 		mutex_lock(&kvm->irqfds.resampler_lock);
  55.  
  56. 		list_for_each_entry(resampler,
  57. 				    &kvm->irqfds.resampler_list, link) {
  58. 			if (resampler->notifier.gsi == irqfd->gsi) {
  59. 				irqfd->resampler = resampler;
  60. 				break;
  61. 			}
  62. 		}
  63.  
  64. 		if (!irqfd->resampler) {
  65. 			resampler = kzalloc(sizeof(*resampler),
  66. 					    GFP_KERNEL_ACCOUNT);
  67. 			if (!resampler) {
  68. 				ret = -ENOMEM;
  69. 				mutex_unlock(&kvm->irqfds.resampler_lock);
  70. 				goto fail;
  71. 			}
  72.  
  73. 			resampler->kvm = kvm;
  74. 			INIT_LIST_HEAD(&resampler->list);
  75. 			resampler->notifier.gsi = irqfd->gsi;
  76. 			resampler->notifier.irq_acked = irqfd_resampler_ack;
  77. 			INIT_LIST_HEAD(&resampler->link);
  78.  
  79. 			list_add(&resampler->link, &kvm->irqfds.resampler_list);
  80. 			kvm_register_irq_ack_notifier(kvm,
  81. 						      &resampler->notifier);
  82. 			irqfd->resampler = resampler;
  83. 		}
  84.  
  85. 		list_add_rcu(&irqfd->resampler_link, &irqfd->resampler->list);
  86. 		synchronize_srcu(&kvm->irq_srcu);
  87.  
  88. 		mutex_unlock(&kvm->irqfds.resampler_lock);
  89. 	}
  90.  
  91. 	/*
  92. 	 * Install our own custom wake-up handling so we are notified via
  93. 	 * a callback whenever someone signals the underlying eventfd
  94. 	 */
  95. 	init_waitqueue_func_entry(&irqfd->wait, irqfd_wakeup);
  96. 	init_poll_funcptr(&irqfd->pt, irqfd_ptable_queue_proc);
  97.  
  98. 	spin_lock_irq(&kvm->irqfds.lock);
  99.  
  100. 	ret = 0;
  101. 	list_for_each_entry(tmp, &kvm->irqfds.items, list) {
  102. 		if (irqfd->eventfd != tmp->eventfd)
  103. 			continue;
  104. 		/* This fd is used for another irq already. */
  105. 		ret = -EBUSY;
  106. 		spin_unlock_irq(&kvm->irqfds.lock);
  107. 		goto fail;
  108. 	}
  109.  
  110. 	idx = srcu_read_lock(&kvm->irq_srcu);
  111. 	irqfd_update(kvm, irqfd);
  112.  
  113. 	list_add_tail(&irqfd->list, &kvm->irqfds.items);
  114.  
  115. 	spin_unlock_irq(&kvm->irqfds.lock);
  116.  
  117. 	/*
  118. 	 * Check if there was an event already pending on the eventfd
  119. 	 * before we registered, and trigger it as if we didn't miss it.
  120. 	 */
  121. 	events = vfs_poll(f.file, &irqfd->pt);
  122.  
  123. 	if (events & EPOLLIN)
  124. 		schedule_work(&irqfd->inject);
  125.  
  126. #ifdef CONFIG_HAVE_KVM_IRQ_BYPASS
  127. 	if (kvm_arch_has_irq_bypass()) {
  128. 		irqfd->consumer.token = (void *)irqfd->eventfd;
  129. 		irqfd->consumer.add_producer = kvm_arch_irq_bypass_add_producer;
  130. 		irqfd->consumer.del_producer = kvm_arch_irq_bypass_del_producer;
  131. 		irqfd->consumer.stop = kvm_arch_irq_bypass_stop;
  132. 		irqfd->consumer.start = kvm_arch_irq_bypass_start;
  133. 		ret = irq_bypass_register_consumer(&irqfd->consumer);
  134. 		if (ret)
  135. 			pr_info("irq bypass consumer (token %p) registration fails: %d\n",
  136. 				irqfd->consumer.token, ret);
  137. 	}
  138. #endif
  139.  
  140. 	srcu_read_unlock(&kvm->irq_srcu, idx);
  141.  
  142. 	/*
  143. 	 * do not drop the file until the irqfd is fully initialized, otherwise
  144. 	 * we might race against the EPOLLHUP
  145. 	 */
  146. 	fdput(f);
  147. 	return 0;
  148.  
  149. fail:
  150. 	if (irqfd->resampler)
  151. 		irqfd_resampler_shutdown(irqfd);
  152.  
  153. 	if (resamplefd && !IS_ERR(resamplefd))
  154. 		eventfd_ctx_put(resamplefd);
  155.  
  156. 	if (eventfd && !IS_ERR(eventfd))
  157. 		eventfd_ctx_put(eventfd);
  158.  
  159. 	fdput(f);
  160.  
  161. out:
  162. 	kfree(irqfd);
  163. 	return ret;
  164. }

在kvm_irqfd_assign函数中，首先申请了一个kvm_kernel_irqfd结构类型的变量irqfd，并为之分配空间，之后对irqfd的各子域进行赋值。代码片段如下： 

  1. 	irqfd = kzalloc(sizeof(*irqfd), GFP_KERNEL_ACCOUNT);
  2. 	if (!irqfd)
  3. 		return -ENOMEM;
  4.  
  5. 	irqfd->kvm = kvm;
  6. 	irqfd->gsi = args->gsi;
  7. 	INIT_LIST_HEAD(&irqfd->list);
  8. 	INIT_WORK(&irqfd->inject, irqfd_inject);
  9. 	INIT_WORK(&irqfd->shutdown, irqfd_shutdown);
  10. 	seqcount_spinlock_init(&irqfd->irq_entry_sc, &kvm->irqfds.lock);

kvm_kernel_irqfd结构中有2个work_struct，inject和shutdown，分别负责触发中断和关闭中断，这两个work_struct各自对应的操作函数分别为irqfd_inject和irqfd_shutdown。

kvm_irq_assign调用init_waitqueue_func_entry函数将 irqfd_wakeup 函数注册为irqfd中 等待队列entry 激活时的处理函数。 这样任何写入该irqfd对应的eventfd的行为都将导致触发这个函数。

然后，kvm_irq_assign函数利用init_poll_funcptr将irqfd_ptable_queue_proc函数注册为irqfd中的poll table的处理函数。 irqfd_ptable_queue_proc会将poll table中对应的wait queue entry加入到waitqueue中去 。代码片段如下： 

  1. 	/*
  2. 	 * Install our own custom wake-up handling so we are notified via
  3. 	 * a callback whenever someone signals the underlying eventfd
  4. 	 */
  5. 	init_waitqueue_func_entry(&irqfd->wait, irqfd_wakeup);
  6. 	init_poll_funcptr(&irqfd->pt, irqfd_ptable_queue_proc);

kvm_irq_assign接着判断该eventfd是否已经被其它中断使用。代码片段如下： 

  1. 	ret = 0;
  2. 	list_for_each_entry(tmp, &kvm->irqfds.items, list) {
  3. 		if (irqfd->eventfd != tmp->eventfd)
  4. 			continue;
  5. 		/* This fd is used for another irq already. */
  6. 		ret = -EBUSY;
  7. 		spin_unlock_irq(&kvm->irqfds.lock);
  8. 		goto fail;
  9. 	}

kvm_irq_assign函数以irqfd->pt为参数，调用eventfd的poll函数，也就是eventfd_poll,后者会调用poll_wait函数，也就是之前为poll table注册的irqfd_ptable_queue_proc函数。irqfd_ptable_queue_proc将irqfd->wait加入到了eventfd的wqh等待队列中。这样，当有其它进程或者内核对eventfd进行write时，就会导致eventfd的wqh等待队列上的对象函数得到执行，也就是irqfd_wakeup函数。

这里只讨论有数据，即flgas中的EPOLLIN置位时，会调用kvm_arch_set_irq_inatomic进行中断注入。

kvm_arch_set_irq_inatomic =>

kvm_set_msi_irq =>

kvm_irq_delivery_to_apic_fast

如果kvm_arch_set_irq_inatomic无法注入中断(即非MSI中断或非HV_SINT中断)，那么就调用irqfd->inject,即调用irqfd_inject函数。 

  1. static void irqfd_inject(struct work_struct *work)
  2. {
  3.     struct kvm_kernel_irqfd *irqfd =
  4.         container_of(work, struct kvm_kernel_irqfd, inject);
  5.     struct kvm *kvm = irqfd->kvm;
  6.  
  7.     if (!irqfd->resampler) {
  8.         kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 1,
  9.                     false);
  10.         kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irqfd->gsi, 0,
  11.                     false);
  12.     } else
  13.         kvm_set_irq(kvm, KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID,
  14.                     irqfd->gsi, 1, false);
  15. }

在irqfd_inject函数中，如果该irqfd配置的中断为边沿触发，则调用两次kvm_set_irq，形成一个中断脉冲，以便KVM中的中断芯片（irqchip）能够感知到这个中断。如果该irqfd配置的中断为电平触发，则调用一次kvm_set_irq，将中断拉至高电平，使irqchip感知到，电平触发的中断信号拉低动作会由后续的irqchip的EOI触发。

总结

irqfd基于eventfd机制，qemu中将一个gsi（全局系统中断号）与eventfd捆绑后，向KVM发送注册irqfd请求。KVM收到请求后将带有gsi信息的eventfd加入到与irqfd有关的等待队列中，一旦有进程向该eventfd写入，等待队列中的元素就会唤醒，并调用相应唤醒函数（irqfd_wakeup）向Guest注入中断，而 注入中断 这一步骤相关知识与特定的中断芯片如PIC、APIC有关。

至此，kvm_arch_init函数的第2个函数kvm_irqfd_init函数就解析完了。下一回继续往下解析kvm_arch_init函数。

举报

选择你想要举报的内容（必选）
  • 内容涉黄
  • 政治相关
  • 内容抄袭
  • 涉嫌广告
  • 内容侵权
  • 侮辱谩骂
  • 样式问题
  • 其他

取消

确定