QEMU

最新推荐文章于 2024-05-28 23:35:14 发布
最新推荐文章于 2024-05-28 23:35:14 发布
阅读量1k 收藏
点赞数
分类专栏： 嵌入式系统

QEMU 1: 使用QEMU创建虚拟机

 

一、QEMU简介

 

QEMU是一款开源的模拟器及虚拟机监管器(Virtual Machine Monitor, VMM)。QEMU主要提供两种功能给用户使用。一是作为用户态模拟器，利用动态代码翻译机制来执行不同于主机架构的代码。二是作为虚拟机监管器，模拟全系统，利用其他VMM(Xen, KVM, etc)来使用硬件提供的虚拟化支持，创建接近于主机性能的虚拟机。

用户可以通过不同Linux发行版所带有的软件包管理器来安装QEMU。如在Debian系列的发行版上可以使用下面的命令来安装：

sudo apt-get install qemu

或者在红帽系列的发行版上使用如下命令安装：

sudo yum install qemu -y

除此之外，也可以选择从源码安装。

获取QEMU源码

可以从QEMU官网上下载QEMU源码的tar包，以命令行下载2.0版本的QEMU为例：

 

  1. $wget http://wiki.qemu-project.org/download/qemu-2.0.0.tar.bz2

  2. $tar xjvf qemu-2.0.0.tar.bz2

如果需要参与到QEMU的开发中，最好使用Git获取源码：

$git clone git://git.qemu-project.org/qemu.git

编译及安装

获取源码后，可以根据需求来配置和编译QEMU。

 

  1. $cd qemu-2.0.0 //如果使用的是git下载的源码，执行cd qemu

  2. $./configure --enable-kvm --enable-debug --enable-vnc --enable-werror --target-list="x86_64-softmmu"

  3. $make -j8

  4. $sudo make install

configure脚本用于生成Makefile，其选项可以用./configure --help查看。这里使用到的选项含义如下：

 

  1. --enable-kvm：编译KVM模块，使QEMU可以利用KVM来访问硬件提供的虚拟化服务。

  2. --enable-vnc：启用VNC。

  3. --enalbe-werror：编译时，将所有的警告当作错误处理。

  4. --target-list：选择目标机器的架构。默认是将所有的架构都编译，但为了更快的完成编译，指定需要的架构即可。

  5.  

二、基本原理

QEMU作为系统模拟器时，会模拟出一台能够独立运行操作系统的虚拟机。如下图所示，每个虚拟机对应主机(Host)中的一个QEMU进程，而虚拟机的vCPU对应QEMU进程的一个线程。

QEMU结构图

系统虚拟化最主要是虚拟出CPU、内存及I/O设备。虚拟出的CPU称之为vCPU，QEMU为了提升效率，借用KVM、XEN等虚拟化技术，直接利用硬件对虚拟化的支持，在主机上安全地运行虚拟机代码(需要硬件支持)。虚拟机vCPU调用KVM的接口来执行任务的流程如下(代码源自QEMU开发者Stefan的技术博客)：

 

  1. open("/dev/kvm")

  2. ioctl(KVM_CREATE_VM)

  3. ioctl(KVM_CREATE_VCPU)

  4. for (;;) {

  5. ioctl(KVM_RUN)

  6. switch (exit_reason) {

  7. case KVM_EXIT_IO: /* ... */

  8. case KVM_EXIT_HLT: /* ... */

  9. }

  10. }

QEMU发起ioctrl来调用KVM接口，KVM则利用硬件扩展直接将虚拟机代码运行于主机之上，一旦vCPU需要操作设备寄存器，vCPU将会停止并退回到QEMU，QEMU去模拟出操作结果。

虚拟机内存会被映射到QEMU的进程地址空间，在启动时分配。在虚拟机看来，QEMU所分配的主机上的虚拟地址空间为虚拟机的物理地址空间。

QEMU在主机用户态模拟虚拟机的硬件设备，vCPU对硬件的操作结果会在用户态进行模拟，如虚拟机需要将数据写入硬盘，实际结果是将数据写入到了主机中的一个镜像文件中。

三、创建及使用虚拟机

命令行创建及启动虚拟机

成功安装QEMU之后便可创建自己的虚拟机。具体步骤如下：

1, 使用qemu-img创建虚拟机镜像。虚拟机镜像用来模拟虚拟机的硬盘，在启动虚拟机之前需要创建镜像文件。

 

  1. [kelvin@kelvin tmp]$ qemu-img create -f qcow2 fedora.img 10G

  2. Formatting 'fedora.img', fmt=qcow2 size=10737418240 encryption=off cluster_size=65536 lazy_refcounts=off

  3. [kelvin@kelvin tmp]$ ls

  4. fedora.img

-f选项用于指定镜像的格式，qcow2格式是QEMU最常用的镜像格式，采用写时复制技术来优化性能。fedora.img是镜像文件的名字，10G是镜像文件大小。镜像文件创建完成后，可使用qemu-system-x86来启动x86架构的虚拟机：

qemu-system-x86_64 fedora.img

此时会弹出一个窗口来作为虚拟机的显示器，显示内容如下：

QEMU虚拟机显示器输出

因为fedora.img中并未给虚拟机安装操作系统，所以会提示“No bootable device”，无可启动设备。

2, 准备操作系统镜像。

可以从不同Linux发行版的官方网站上获取安装镜像，以fedora20为例：

[kelvin@kelvin tmp]$ wget http://ftp6.sjtu.edu.cn/fedora/linux/releases/20/Live/x86_64/Fedora-Live-Desktop-x86_64-20-1.iso

3, 检查KVM是否可用。

QEMU使用KVM来提升虚拟机性能，如果不启用KVM会导致性能损失。要使用KVM，首先要检查硬件是否有虚拟化支持：

[kelvin@kelvin ~]$ grep -E 'vmx|svm' /proc/cpuinfo

如果有输出则表示硬件有虚拟化支持。其次要检查kvm模块是否已经加载：

 

  1. [kelvin@kelvin ~]$ lsmod | grep kvm

  2. kvm_intel 142999 0

  3. kvm 444314 1 kvm_intel

如果kvm_intel/kvm_amd、kvm模块被显示出来，则kvm模块已经加载。最后要确保qemu在编译的时候使能了KVM，即在执行configure脚本的时候加入了–enable-kvm选项。

4, 启动虚拟机安装操作系统。

执行下面的命令启动带有cdrom的虚拟机：

[kelvin@kelvin tmp]$ qemu-system-x86_64 -m 2048 -enable-kvm fedora.img -cdrom ./Fedora-Live-Desktop-x86_64-20-1.iso

-m 指定虚拟机内存大小，默认单位是MB， -enable-kvm使用KVM进行加速，-cdrom添加fedora的安装镜像。可在弹出的窗口中操作虚拟机，安装操作系统，安装完成后重起虚拟机便会从硬盘(fedora.img)启动。之后再启动虚拟机只需要执行：

[kelvin@kelvin tmp]$ qemu-system-x86_64 -m 2048 -enable-kvm fedora.img

即可。

图形界面创建及启动虚拟机

命令行启动虚拟机比较繁琐，适合开发者，但对于普通用户来说，采用图形界面管理虚拟机则更为方便。采用图形界面管理QEMU虚拟机需要安装virt-manager，红帽系列的发行版只需要执行命令：

$sudo yum install virt-manager -y

安装完成后用root用户启动virt-manager：

 

  1. $su -

  2. #virt-manager

启动后的界面如下图所示：

virt-manager界面

点击左上角电脑图标即可创建虚拟机。按照步骤操作即可完成对虚拟机的创建。

 

 

QEMU 2: 参数解析

 

一、使用gdb分析QEMU代码

 

使用gdb不仅可以很好地调试代码，也可以利用它来动态地分析代码。使用gdb调试QEMU需要做一些准备工作：

1, 编译QEMU时需要在执行configure脚本时的参数中加入–enable-debug。

2, 从QEMU官方网站上下载一个精简的镜像——linux-0.2.img。linux-0.2.img只有8MB大小，启动后包含一些常用的shell命令，用于QEMU的测试。

 

  1. $wget http://wiki.qemu.org/download/linux-0.2.img.bz2

  2. $bzip2 -d ./linux-0.2.img.bz2

3, 启动gdb调试QEMU：

gdb --args qemu-system-x86_64 -enable-kvm -m 4096 -smp 4 linux-0.2.img

-smp指定处理器个数。

二、参数解析用到的数据结构

QEMU系统模拟的主函数位于vl.c文件，无论是qemu-system-x86_64还是qemu-system-ppc64，都是从vl.c中的main函数开始执行。下面先介绍main函数涉及到的一些数据结构。

QEMU链表

QEMU的链表在include/qemu/queue.h文件中定义，分为四种类型：

  • 单链表(singly-linked list)：单链表适用于大的数据集，并且很少有删除节点或者移动节点的操作，也适用于实现后进先出的队列。
  • 链表(list)：即双向链表，除了头节点之外每个节点都会同时指向前一个节点和后一个节点。
  • 简单队列(simple queue)：简单队列类似于单链表，只是多了一个指向链表尾的一个表头，插入节点的时候不仅可以像单链表那样将其插入表头或者某节点之后，还可以插入到链表尾。
  • 尾队列(tail queue)：类似于简单队列，但节点之间是双向指向的。

这里不一一介绍各种链表的用法，只通过NotifierList的定义来说明QEMU链表(list)的用法。在main函数的开头定义的DisplayState结构体使用到了NotifiereList，NotifierList就用到了链表。

a. 表头及节点的定义

定义表头需要用到QLIST_HEAD，定义如下：

 

  1. 86 #define QLIST_HEAD(name, type) \

  2. 87 struct name { \

  3. 88 struct type *lh_first; /* first element */ \

  4. 89 }

NotifierList就采用了QLIST_HEAD来定义表头：

 

  1. 27 typedef struct NotifierList

  2. 28 {

  3. 29 QLIST_HEAD(, Notifier) notifiers;

  4. 30 } NotifierList;

定义节点需要用到QLIST_ENTRY，定义如下：

 

  1. 94 #define QLIST_ENTRY(type) \

  2. 95 struct { \

  3. 96 struct type *le_next; /* next element */ \

  4. 97 struct type **le_prev; /* address of previous next element */ \

  5. 98 }

Notifier的节点定义如下：

 

  1. 21 struct Notifier

  2. 22 {

  3. 23 void (*notify)(Notifier *notifier, void *data);

  4. 24 QLIST_ENTRY(Notifier) node;

  5. 25 };

b. 初始化表头

初始化表头用到QLIST_INIT：

 

  1. 103 #define QLIST_INIT(head) do { \

  2. 104 (head)->lh_first = NULL; \

  3. 105 } while (/*CONSTCOND*/0)

初始化NotifierList就可以这样进行：

 

  1. 19 void notifier_list_init(NotifierList *list)

  2. 20 {

  3. 21 QLIST_INIT(&list->notifiers);

  4. 22 }

c. 在表头插入节点

将节点插入到表头使用QLIST_INSERT_HEAD：

 

  1. 122 #define QLIST_INSERT_HEAD(head, elm, field) do { \

  2. 123 if (((elm)->field.le_next = (head)->lh_first) != NULL) \

  3. 124 (head)->lh_first->field.le_prev = &(elm)->field.le_next;\

  4. 125 (head)->lh_first = (elm); \

  5. 126 (elm)->field.le_prev = &(head)->lh_first; \

  6. 127 } while (/*CONSTCOND*/0)

插入Notifier到NotifierList：

 

  1. 24 void notifier_list_add(NotifierList *list, Notifier *notifier)

  2. 25 {

  3. 26 QLIST_INSERT_HEAD(&list->notifiers, notifier, node);

  4. 27 }

d. 遍历节点

遍历节点使用QLIST_FOREACH或者QLIST_FOREACH_SAFE，QLIST_FOREACH_SAFE是为了防止遍历过程中删除了节点，从而导致le_next被释放掉，中断了遍历。

 

  1. 147 #define QLIST_FOREACH(var, head, field) \

  2. 148 for ((var) = ((head)->lh_first); \

  3. 149 (var); \

  4. 150 (var) = ((var)->field.le_next))

  5. 151

  6. 152 #define QLIST_FOREACH_SAFE(var, head, field, next_var) \

  7. 153 for ((var) = ((head)->lh_first); \

  8. 154 (var) && ((next_var) = ((var)->field.le_next), 1); \

  9. 155 (var) = (next_var))

  10.  

NotifierList在执行所有的回调函数时就用到了QLIST_FOREACH_SAFE：

 

  1. 34 void notifier_list_notify(NotifierList *list, void *data)

  2. 35 {

  3. 36 Notifier *notifier, *next;

  4. 37

  5. 38 QLIST_FOREACH_SAFE(notifier, &list->notifiers, node, next) {

  6. 39 notifier->notify(notifier, data);

  7. 40 }

  8. 41 }

Error和QError

为了方便的处理错误信息，QEMU定义了Error和QError两个数据结构。Error在qobject/qerror.c中定义：

 

  1. 101 struct Error

  2. 102 {

  3. 103 char *msg;

  4. 104 ErrorClass err_class;

  5. 105 };

包含了错误消息字符串和枚举类型的错误类别。错误类别有下面几个：

 

  1. 139 typedef enum ErrorClass

  2. 140 {

  3. 141 ERROR_CLASS_GENERIC_ERROR = 0,

  4. 142 ERROR_CLASS_COMMAND_NOT_FOUND = 1,

  5. 143 ERROR_CLASS_DEVICE_ENCRYPTED = 2,

  6. 144 ERROR_CLASS_DEVICE_NOT_ACTIVE = 3,

  7. 145 ERROR_CLASS_DEVICE_NOT_FOUND = 4,

  8. 146 ERROR_CLASS_K_V_M_MISSING_CAP = 5,

  9. 147 ERROR_CLASS_MAX = 6,

  10. 148 } ErrorClass;

QEMU在util/error.c中定义了几个函数来对Error进行操作：

 

  1. error_set //根据给定的ErrorClass以及格式化字符串来给Error分配空间并赋值

  2. error_set_errno //除了error_set的功能外，将指定errno的错误信息追加到格式化字符串的后面

  3. error_copy //复制Error

  4. error_is_set //判断Error是否已经分配并设置

  5. error_get_class //获取Error的ErrorClass

  6. error_get_pretty //获取Error的msg

  7. error_free //释放Error及msg的空间

另外，QEMU定义了QError来处理更为细致的错误信息：

 

  1. 22 typedef struct QError {

  2. 23 QObject_HEAD;

  3. 24 Location loc;

  4. 25 char *err_msg;

  5. 26 ErrorClass err_class;

  6. 27 } QError;

QError可以通过一系列的宏来给err_msg及err_class赋值：

 

  1. 39 #define QERR_ADD_CLIENT_FAILED \

  2. 40 ERROR_CLASS_GENERIC_ERROR, "Could not add client"

  3. 41

  4. 42 #define QERR_AMBIGUOUS_PATH \

  5. 43 ERROR_CLASS_GENERIC_ERROR, "Path '%s' does not uniquely identify an object"

  6. 44

  7. 45 #define QERR_BAD_BUS_FOR_DEVICE \

  8. 46 ERROR_CLASS_GENERIC_ERROR, "Device '%s' can't go on a %s bus"

  9. 47

  10. 48 #define QERR_BASE_NOT_FOUND \

  11. 49 ERROR_CLASS_GENERIC_ERROR, "Base '%s' not found"

  12. ...

Location记录了出错的位置，定义如下：

 

  1. 20 typedef struct Location {

  2. 21 /* all members are private to qemu-error.c */

  3. 22 enum { LOC_NONE, LOC_CMDLINE, LOC_FILE } kind;

  4. 23 int num;

  5. 24 const void *ptr;

  6. 25 struct Location *prev;

  7. 26 } Location;

  8.  

GMainLoop

QEMU使用glib中的GMainLoop来实现IO多路复用，关于GMainLoop可以参考博客GMainLoop的实现原理和代码模型。由于GMainLoop并非QEMU本身的代码，本文就不重复赘述。

三、QEMUOption、QemuOpt及QEMU参数解析

QEMU定义了QEMUOption来表示执行qemu-system-x86_64等命令时用到的选项。在vl.c中定义如下：

 

  1. 2123 typedef struct QEMUOption {

  2. 2124 const char *name; //选项名，如 -device, name的值就是device

  3. 2125 int flags; //标志位，表示选项是否带参数，可以是0，或者HAS_ARG(值为0x0001)

  4. 2126 int index; //枚举类型的值，如-device，该值就是QEMU_OPTION_device

  5. 2127 uint32_t arch_mask; // 选项支持架构的掩码

  6. 2128 } QEMUOption;

vl.c中维护了一个QEMUOption数组qemu_options来存储所有可用的选项，并利用qemu-options-wrapper.h和qemu-options.def来给该数组赋值。赋值语句如下：

 

  1. 2130 static const QEMUOption qemu_options[] = {

  2. 2131 { "h", 0, QEMU_OPTION_h, QEMU_ARCH_ALL },

  3. 2132 #define QEMU_OPTIONS_GENERATE_OPTIONS

  4. 2133 #include "qemu-options-wrapper.h"

  5. 2134 { NULL },

  6. 2135 };

#define QEMU_OPTIONS_GENERATE_OPTIONS选择qemu-options-wrapper.h的操作，qemu-options-wrapper.h可以进行三种操作：

 

  1. QEMU_OPTIONS_GENERATE_ENUM: 利用qemu-options.def生成一个枚举值列表，就是上面提到的QEMU_OPTION_device等

  2. QEMU_OPTIONS_GENERATE_HELP: 利用qemu-options.def生成帮助信息并输出到标准输出

  3. QEMU_OPTIONS_GENERATE_OPTIONS: 利用qemu-options.def生成一组选项列表

可以通过下面的方法来展开qemu-options-wrapper.h来查看上述操作的结果，以生成选项为例。

  1. 在qemu-options-wrapper.h第一行写入#define QEMU_OPTIONS_GENERATE_OPTIONS.
  2. 执行命令gcc -E -o options.txt qemu-options-wrapper.h
  3. 查看文件options.txt即可

给qemu_options数组赋值后，QEMU就有了一个所有可用选项的集合。之后在vl.c中main函数的一个for循环根据这个集合开始解析命令行。for循环的框架大致如下：

 

  1. 1 for(;;) {

  2. 2 if (optind >= argc)

  3. 3 break;

  4. 4 if (argv[optind][0] != '-') {

  5. 5 hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);

  6. 6 } else {

  7. 7 const QEMUOption *popt;

  8. 8

  9. 9 popt = lookup_opt(argc, argv, &optarg, &optind);

  10. 10 if (!(popt->arch_mask & arch_type)) {

  11. 11 printf("Option %s not supported for this target\n", popt->name);

  12. 12 exit(1);

  13. 13 }

  14. 14 switch(popt->index) {

  15. 15 case QEMU_OPTION_M:

  16. 16 ......

  17. 17 case QEMU_OPTION_hda:

  18. 18 ......

  19. 19 case QEMU_OPTION_watchdog:

  20. 20 ......

  21. 21 default:

  22. 22 os_parse_cmd_args(popt->index, optarg);

  23. 23 }

  24. 24 }

  25. 25 }

QEMU会把argv中以'-'开头的字符串当作选项，然后调用lookup_opt函数到qemu_options数组中查找该选项，如果查找到的选项中flags的值是HAS_ARG，lookup_opt也会将参数字符串赋值给optarg。找到选项和参数之后，QEMU便根据选项中的index枚举值来执行不同的分支。

对于一些开关性质的选项，分支执行时仅仅是把相关的标志位赋值而已，如：

 

  1. 3712 case QEMU_OPTION_old_param:

  2. 3713 old_param = 1;

  3. 3714 break;

也有一些选项没有子选项，分支执行时就直接把optarg的值交给相关变量：

 

  1. 3822 case QEMU_OPTION_qtest:

  2. 3823 qtest_chrdev = optarg;

  3. 3824 break;

对于那些拥有子选项的选项，如”-drive if=none,id=DRIVE-ID”，QEMU的处理会更为复杂一些。它会调用qemu_opts_parse来解析子选项，如realtime选项的解析：

 

  1. 3852 case QEMU_OPTION_realtime:

  2. 3853 opts = qemu_opts_parse(qemu_find_opts("realtime"), optarg, 0);

  3. 3854 if (!opts) {

  4. 3855 exit(1);

  5. 3856 }

  6. 3857 configure_realtime(opts);

  7. 3858 break;

对子选项的解析涉及到4个数据结构：QemuOpt, QemuDesc, QemuOpts, QemuOptsList. 它们的关系如下图所示：

Qemu选项数据结构关系图

QemuOpt存储子选项，每个QemuOpt有一个QemuOptDesc来描述该子选项名字、类型、及帮助信息。两个结构体定义如下：

 

  1. 32 struct QemuOpt {

  2. 33 const char *name; //子选项的名字

  3. 34 const char *str; //字符串值

  4. 35

  5. 36 const QemuOptDesc *desc;

  6. 37 union {

  7. 38 bool boolean; //布尔值

  8. 39 uint64_t uint; //数字或者大小

  9. 40 } value;

  10. 41

  11. 42 QemuOpts *opts;

  12. 43 QTAILQ_ENTRY(QemuOpt) next;

  13. 44 };

  14.  

  15. 95 typedef struct QemuOptDesc {

  16. 96 const char *name;

  17. 97 enum QemuOptType type;

  18. 98 const char *help;

  19. 99 } QemuOptDesc;

子选项的类型可以是：

 

  1. 88 enum QemuOptType {

  2. 89 QEMU_OPT_STRING = 0, // 字符串

  3. 90 QEMU_OPT_BOOL, // 取值可以是on或者off

  4. 91 QEMU_OPT_NUMBER, // 数字

  5. 92 QEMU_OPT_SIZE, // 大小，可以有K, M, G, T等后缀

  6. 93 };

QEMU维护了一个QemuOptsList*的数组，在util/qemu-config.c中定义：

10 static QemuOptsList *vm_config_groups[32];

在main函数中由qemu_add_opts将各种QemuOptsList写入到数组中：

 

  1. 2944 qemu_add_opts(&qemu_drive_opts);

  2. 2945 qemu_add_opts(&qemu_chardev_opts);

  3. 2946 qemu_add_opts(&qemu_device_opts);

  4. 2947 qemu_add_opts(&qemu_netdev_opts);

  5. 2948 qemu_add_opts(&qemu_net_opts);

  6. 2949 qemu_add_opts(&qemu_rtc_opts);

  7. 2950 qemu_add_opts(&qemu_global_opts);

  8. 2951 qemu_add_opts(&qemu_mon_opts);

  9. 2952 qemu_add_opts(&qemu_trace_opts);

  10. 2953 qemu_add_opts(&qemu_option_rom_opts);

  11. 2954 qemu_add_opts(&qemu_machine_opts);

  12. 2955 qemu_add_opts(&qemu_smp_opts);

  13. 2956 qemu_add_opts(&qemu_boot_opts);

  14. 2957 qemu_add_opts(&qemu_sandbox_opts);

  15. 2958 qemu_add_opts(&qemu_add_fd_opts);

  16. 2959 qemu_add_opts(&qemu_object_opts);

  17. 2960 qemu_add_opts(&qemu_tpmdev_opts);

  18. 2961 qemu_add_opts(&qemu_realtime_opts);

  19. 2962 qemu_add_opts(&qemu_msg_opts);

每个QemuOptsList存储了大选项所支持的所有小选项，如-realtime大选项QemuOptsList的定义：

 

  1. 507 static QemuOptsList qemu_realtime_opts = {

  2. 508 .name = "realtime",

  3. 509 .head = QTAILQ_HEAD_INITIALIZER(qemu_realtime_opts.head),

  4. 510 .desc = {

  5. 511 {

  6. 512 .name = "mlock",

  7. 513 .type = QEMU_OPT_BOOL,

  8. 514 },

  9. 515 { /* end of list */ }

  10. 516 },

  11. 517 };

-realtime只支持1个子选项，且值为bool类型，即只能是on或者off。

在调用qemu_opts_parse解析子选项之前，QEMU会调用qemu_find_opts(“realtime”)，把QemuOptsList *从qemu_add_opts中找出来，和optarg一起传递给qemu_opts_parse去解析。QEMU可能会多次使用同一个大选项来指定多个相同的设备，在这种情况下，需要用id来区分。QemuOpts结构体就表示同一id下所有的子选项，定义如下：

 

  1. 46 struct QemuOpts {

  2. 47 char *id;

  3. 48 QemuOptsList *list;

  4. 49 Location loc;

  5. 50 QTAILQ_HEAD(QemuOptHead, QemuOpt) head;

  6. 51 QTAILQ_ENTRY(QemuOpts) next;

  7. 52 };

其中list是同一个大选项下不同id的QemuOpts链表。

yedushu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
qemu
数字人生
10-17 221
当Ubuntu下配置QEMU时出现：的错误时，意思是缺少了glib2库，此处通过搜索：找到了是：libglib2.0-devsudoinstallQEMU (Quick EMUlator) 是一个开源的处理器模拟工具，它可以模拟多种硬件架构（如 x86, ARM, MIPS 等）以及相关的硬件组件（如网络设备、磁盘控制器等）。QEMU 主要用于虚拟化、测试和开发目的。
qemu-w64-setup-20220831.exe
09-21
QEMU（Quick Emulator）是一款强大的开源模拟器和虚拟化软件，它允许用户在一台计算机上运行多种操作系统，而无需实际硬件。QEMU-w64-setup-20220831.exe 是QEMU针对64位Windows系统的安装程序，发布于2022年8月31日...
Windows11系统安装QEMU虚拟化软件
最新发布
番茄打电脑的博客
05-28 1179
QEMU软件是一个通用的开源机器模拟器和虚拟机。本文档适用于在Windows 11系统平台上安装QEMU软件。
Qemu 简述
weixin_33921089的博客
11-19 2532
Qemu 架构 Qemu 是纯软件实现的虚拟化模拟器，几乎可以模拟任何硬件设备，我们最熟悉的就是能够模拟一台能够独立运行操作系统的虚拟机，虚拟机认为自己和硬件打交道，但其实是和 Qemu 模拟出来的硬件打交道，Qemu 将这些指令转译给真正的硬件。 正因为 Qemu 是纯软件实现的，所有的指令都要经 Qemu 过一手，性能非常低，所以，在生产环境中，大多数的做法都是配合 KVM 来完成虚拟化工作，...
qemu是什么
斯坦福-MIT-Harvard-CMU
11-06 811
QEMU（Quick Emulator）是一个开源的虚拟机监控器和仿真器，它允许在不同的硬件平台上执行虚拟机。QEMU最初是用于在Linux系统上运行不同体系结构的二进制代码，但后来它扩展到支持多种硬件架构和操作系统。QEMU作为虚拟机监控器，它管理虚拟机的生命周期，包括虚拟机的创建、启动、停止和销毁。它还提供了虚拟机的资源管理和访问控制。QEMU提供硬件仿真，允许在一个虚拟环境中运行不同体系结构的操作系统和应用程序。
QEMU是什么？
qq_44062110的博客
03-06 796
它允许您在一个平台上运行一个或多个操作系统，这些操作系统与宿主机（即运行 QEMU 的机器）的原生操作系统完全隔离。QEMU 可以在没有硬件加速支持的情况下通过解释执行指令来模拟整个计算机系统，也可以在支持虚拟化技术（如 Intel VT 或 AMD-V）的硬件上运行，提供接近原生的性能。QEMU 可以独立使用，也经常与其他虚拟化和模拟工具一起使用，如 VirtualBox 或 VMware 提供的用户界面，或者与 libvirt 这样的虚拟化管理库配合使用，以简化虚拟机的管理和操作。
qemu Windows版
02-11
qemu Windows版
QEMU Binaries for Windows (64 bit) qemu-w64-setup-20220831.exe
09-06
QEMUwindows版本2022年8月份最新版qemu-w64-setup-20220831.exe
Sifive的qemu仿真环境的搭建
04-12
### Sifive的QEMU仿真环境搭建详解 #### 一、引言 随着RISC-V架构的日益流行，越来越多的开发者开始关注并投入到基于RISC-V的开发工作中。其中，Sifive作为RISC-V领域的重要公司之一，其提供的QEMU仿真环境成为了...
Qemu模拟器运行AIX 7.2 系统.docx
10-13
### QEMU模拟器运行AIX 7.2系统的详细指南 #### AIX操作系统简介 AIX（Advanced Interactive Executive）是IBM公司开发的一款基于AT&T Unix System V的类UNIX操作系统，主要用于IBM Power架构的服务器和工作站上。...
介绍QEMU 原理的文档资料
08-08
What is QEMU ? 简单文档，描述QEMU和原理图的。
传奇的程序员--Fabrice Bellard
刘家军的技术博客
06-08 2055
<br />Fabrice Bellard，法国著名程序员，QEMU, TinyCC, FFMPEG等作者。 <br /> <br />这个世界从来不缺天才，只缺乏利用天分坚持理想和信念不断创新的人，这些人用恒心和努力缔造一个又一个传奇。法国人Fabrice Bellard 就是这样一个了不起的程序员。 <br /><br />Fabrice Bellard 1972年生于法国，曾就读于巴黎高等综合理工学院和法国电信研究院。对计算机有着浓厚兴趣的他，高中时就崭露头角，编写出了LZEXE，这是DOS上第一个广
QEMU（Quick Emulator）
我的博客
07-30 696
QEMU（Quick Emulator）是一款由法布里斯·贝拉等人编写的免费的可执行硬件虚拟化的开源托管虚拟机。它可以通过动态的二进制转换模拟CPU，并提供一组设备模型，使它能够运行多种未修改的客户机OS。QEMU还可以为user-level的进程执行CPU仿真，进而允许为一种架构编译的程序在另一种架构上面运行。综上所述，QEMU的应用场景非常广泛，可以在不同情况下模拟和转换不同的CPU架构，实现跨平台运行程序，也可以在虚拟化环境中提供接近本机性能的执行环境。
关于qemu
困囝的博客
04-09 4046
一、什么是Qemu？Qemu 是纯软件实现的虚拟化模拟器，几乎可以模拟任何硬件设备，我们最熟悉的就是能够模拟一台能够独立运行操作系统的虚拟机，虚拟机认为自己和硬件打交道，但其实是和 Qemu 模拟出来的硬件打交道，Qemu 将这些指令转译给真正的硬件。正因为 Qemu 是纯软件实现的，所有的指令都要经 Qemu 过一手，性能非常低，所以，在生产环境中，大多数的做法都是配合 KVM 来完成虚拟化工作...
QEMU手册
yedushu的博客
08-14 1894
https://qemu.weilnetz.de/doc/qemu-doc.html
QEMU介绍
pkufergus的专栏
04-01 3433
QEMU 作为开源界最热门的 Emulator，被广泛的应用在诸如内核调试，跨平台开发等领域。例如现在很火的 Android 上的手机应用开发，就需要用到的基于 QEMU 的 Android Emulator。 QEMU Internals 首先介绍一下 QEMU 中访存相关的几个设计，由于接触 QEMU 源代码时间还不长，如有什么疏漏还请各位大牛指正。 TB TB (
利用QEMU虚拟机加速嵌入式设备驱动开发
本篇文档《如何使用QEMU机器模拟器开发嵌入式软件》由Apriorit Inc.的软件分析师Artem Kotovsky撰写，专为嵌入式软件开发者提供了一份详尽指南。它探讨了如何通过QEMU（Quick Emulator）这种虚拟化技术，有效地缩短...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值