qemu-tech.texi

   1 @node Implementation notes
   2 @appendix Implementation notes
   3
   4 @menu
   5 * CPU emulation::
   6 * Translator Internals::
   7 * QEMU compared to other emulators::
   8 * Managed start up options::
   9 * Bibliography::
  10 @end menu
  11
  12 @node CPU emulation
  13 @section CPU emulation
  14
  15 @menu
  16 * x86::     x86 and x86-64 emulation
  17 * ARM::     ARM emulation
  18 * MIPS::    MIPS emulation
  19 * PPC::     PowerPC emulation
  20 * SPARC::   Sparc32 and Sparc64 emulation
  21 * Xtensa::  Xtensa emulation
  22 @end menu
  23
  24 @node x86
  25 @subsection x86 and x86-64 emulation
  26
  27 QEMU x86 target features:
  28
  29 @itemize
  30
  31 @item The virtual x86 CPU supports 16 bit and 32 bit addressing with segmentation.
  32 LDT/GDT and IDT are emulated. VM86 mode is also supported to run
  33 DOSEMU. There is some support for MMX/3DNow!, SSE, SSE2, SSE3, SSSE3,
  34 and SSE4 as well as x86-64 SVM.
  35
  36 @item Support of host page sizes bigger than 4KB in user mode emulation.
  37
  38 @item QEMU can emulate itself on x86.
  39
  40 @item An extensive Linux x86 CPU test program is included @file{tests/test-i386}.
  41 It can be used to test other x86 virtual CPUs.
  42
  43 @end itemize
  44
  45 Current QEMU limitations:
  46
  47 @itemize
  48
  49 @item Limited x86-64 support.
  50
  51 @item IPC syscalls are missing.
  52
  53 @item The x86 segment limits and access rights are not tested at every
  54 memory access (yet). Hopefully, very few OSes seem to rely on that for
  55 normal use.
  56
  57 @end itemize
  58
  59 @node ARM
  60 @subsection ARM emulation
  61
  62 @itemize
  63
  64 @item Full ARM 7 user emulation.
  65
  66 @item NWFPE FPU support included in user Linux emulation.
  67
  68 @item Can run most ARM Linux binaries.
  69
  70 @end itemize
  71
  72 @node MIPS
  73 @subsection MIPS emulation
  74
  75 @itemize
  76
  77 @item The system emulation allows full MIPS32/MIPS64 Release 2 emulation,
  78 including privileged instructions, FPU and MMU, in both little and big
  79 endian modes.
  80
  81 @item The Linux userland emulation can run many 32 bit MIPS Linux binaries.
  82
  83 @end itemize
  84
  85 Current QEMU limitations:
  86
  87 @itemize
  88
  89 @item Self-modifying code is not always handled correctly.
  90
  91 @item 64 bit userland emulation is not implemented.
  92
  93 @item The system emulation is not complete enough to run real firmware.
  94
  95 @item The watchpoint debug facility is not implemented.
  96
  97 @end itemize
  98
  99 @node PPC
 100 @subsection PowerPC emulation
 101
 102 @itemize
 103
 104 @item Full PowerPC 32 bit emulation, including privileged instructions,
 105 FPU and MMU.
 106
 107 @item Can run most PowerPC Linux binaries.
 108
 109 @end itemize
 110
 111 @node SPARC
 112 @subsection Sparc32 and Sparc64 emulation
 113
 114 @itemize
 115
 116 @item Full SPARC V8 emulation, including privileged
 117 instructions, FPU and MMU. SPARC V9 emulation includes most privileged
 118 and VIS instructions, FPU and I/D MMU. Alignment is fully enforced.
 119
 120 @item Can run most 32-bit SPARC Linux binaries, SPARC32PLUS Linux binaries and
 121 some 64-bit SPARC Linux binaries.
 122
 123 @end itemize
 124
 125 Current QEMU limitations:
 126
 127 @itemize
 128
 129 @item IPC syscalls are missing.
 130
 131 @item Floating point exception support is buggy.
 132
 133 @item Atomic instructions are not correctly implemented.
 134
 135 @item There are still some problems with Sparc64 emulators.
 136
 137 @end itemize
 138
 139 @node Xtensa
 140 @subsection Xtensa emulation
 141
 142 @itemize
 143
 144 @item Core Xtensa ISA emulation, including most options: code density,
 145 loop, extended L32R, 16- and 32-bit multiplication, 32-bit division,
 146 MAC16, miscellaneous operations, boolean, FP coprocessor, coprocessor
 147 context, debug, multiprocessor synchronization,
 148 conditional store, exceptions, relocatable vectors, unaligned exception,
 149 interrupts (including high priority and timer), hardware alignment,
 150 region protection, region translation, MMU, windowed registers, thread
 151 pointer, processor ID.
 152
 153 @item Not implemented options: data/instruction cache (including cache
 154 prefetch and locking), XLMI, processor interface. Also options not
 155 covered by the core ISA (e.g. FLIX, wide branches) are not implemented.
 156
 157 @item Can run most Xtensa Linux binaries.
 158
 159 @item New core configuration that requires no additional instructions
 160 may be created from overlay with minimal amount of hand-written code.
 161
 162 @end itemize
 163
 164 @node QEMU compared to other emulators
 165 @section QEMU compared to other emulators
 166
 167 Like bochs [1], QEMU emulates an x86 CPU. But QEMU is much faster than
 168 bochs as it uses dynamic compilation. Bochs is closely tied to x86 PC
 169 emulation while QEMU can emulate several processors.
 170
 171 Like Valgrind [2], QEMU does user space emulation and dynamic
 172 translation. Valgrind is mainly a memory debugger while QEMU has no
 173 support for it (QEMU could be used to detect out of bound memory
 174 accesses as Valgrind, but it has no support to track uninitialised data
 175 as Valgrind does). The Valgrind dynamic translator generates better code
 176 than QEMU (in particular it does register allocation) but it is closely
 177 tied to an x86 host and target and has no support for precise exceptions
 178 and system emulation.
 179
 180 EM86 [3] is the closest project to user space QEMU (and QEMU still uses
 181 some of its code, in particular the ELF file loader). EM86 was limited
 182 to an alpha host and used a proprietary and slow interpreter (the
 183 interpreter part of the FX!32 Digital Win32 code translator [4]).
 184
 185 TWIN from Willows Software was a Windows API emulator like Wine. It is less
 186 accurate than Wine but includes a protected mode x86 interpreter to launch
 187 x86 Windows executables. Such an approach has greater potential because most
 188 of the Windows API is executed natively but it is far more difficult to
 189 develop because all the data structures and function parameters exchanged
 190 between the API and the x86 code must be converted.
 191
 192 User mode Linux [5] was the only solution before QEMU to launch a
 193 Linux kernel as a process while not needing any host kernel
 194 patches. However, user mode Linux requires heavy kernel patches while
 195 QEMU accepts unpatched Linux kernels. The price to pay is that QEMU is
 196 slower.
 197
 198 The Plex86 [6] PC virtualizer is done in the same spirit as the now
 199 obsolete qemu-fast system emulator. It requires a patched Linux kernel
 200 to work (you cannot launch the same kernel on your PC), but the
 201 patches are really small. As it is a PC virtualizer (no emulation is
 202 done except for some privileged instructions), it has the potential of
 203 being faster than QEMU. The downside is that a complicated (and
 204 potentially unsafe) host kernel patch is needed.
 205
 206 The commercial PC Virtualizers (VMWare [7], VirtualPC [8]) are faster
 207 than QEMU (without virtualization), but they all need specific, proprietary
 208 and potentially unsafe host drivers. Moreover, they are unable to
 209 provide cycle exact simulation as an emulator can.
 210
 211 VirtualBox [9], Xen [10] and KVM [11] are based on QEMU. QEMU-SystemC
 212 [12] uses QEMU to simulate a system where some hardware devices are
 213 developed in SystemC.
 214
 215 @node Managed start up options
 216 @section Managed start up options
 217
 218 In system mode emulation, it's possible to create a VM in a paused state using
 219 the -S command line option. In this state the machine is completely initialized
 220 according to command line options and ready to execute VM code but VCPU threads
 221 are not executing any code. The VM state in this paused state depends on the way
 222 QEMU was started. It could be in:
 223 @table @asis
 224 @item initial state (after reset/power on state)
 225 @item with direct kernel loading, the initial state could be amended to execute
 226 code loaded by QEMU in the VM's RAM and with incoming migration
 227 @item with incoming migration, initial state will by amended with the migrated
 228 machine state after migration completes.
 229 @end table
 230
 231 This paused state is typically used by users to query machine state and/or
 232 additionally configure the machine (by hotplugging devices) in runtime before
 233 allowing VM code to run.
 234
 235 However, at the -S pause point, it's impossible to configure options that affect
 236 initial VM creation (like: -smp/-m/-numa ...) or cold plug devices. The
 237 experimental --preconfig command line option  allows pausing QEMU
 238 before the initial VM creation, in a ``preconfig'' state, where additional
 239 queries and configuration can be performed via QMP before moving on to
 240 the resulting configuration startup. In the preconfig state, QEMU only allows
 241 a limited set of commands over the QMP monitor, where the commands do not
 242 depend on an initialized machine, including but not limited to:
 243 @table @asis
 244 @item qmp_capabilities
 245 @item query-qmp-schema
 246 @item query-commands
 247 @item query-status
 248 @item x-exit-preconfig
 249 @end table
 250
 251 @node Bibliography
 252 @section Bibliography
 253
 254 @table @asis
 255
 256 @item [1]
 257 @url{http://bochs.sourceforge.net/}, the Bochs IA-32 Emulator Project,
 258 by Kevin Lawton et al.
 259
 260 @item [2]
 261 @url{http://www.valgrind.org/}, Valgrind, an open-source memory debugger
 262 for GNU/Linux.
 263
 264 @item [3]
 265 @url{http://ftp.dreamtime.org/pub/linux/Linux-Alpha/em86/v0.2/docs/em86.html},
 266 the EM86 x86 emulator on Alpha-Linux.
 267
 268 @item [4]
 269 @url{http://www.usenix.org/publications/library/proceedings/usenix-nt97/@/full_papers/chernoff/chernoff.pdf},
 270 DIGITAL FX!32: Running 32-Bit x86 Applications on Alpha NT, by Anton
 271 Chernoff and Ray Hookway.
 272
 273 @item [5]
 274 @url{http://user-mode-linux.sourceforge.net/},
 275 The User-mode Linux Kernel.
 276
 277 @item [6]
 278 @url{http://www.plex86.org/},
 279 The new Plex86 project.
 280
 281 @item [7]
 282 @url{http://www.vmware.com/},
 283 The VMWare PC virtualizer.
 284
 285 @item [8]
 286 @url{https://www.microsoft.com/download/details.aspx?id=3702},
 287 The VirtualPC PC virtualizer.
 288
 289 @item [9]
 290 @url{http://virtualbox.org/},
 291 The VirtualBox PC virtualizer.
 292
 293 @item [10]
 294 @url{http://www.xen.org/},
 295 The Xen hypervisor.
 296
 297 @item [11]
 298 @url{http://www.linux-kvm.org/},
 299 Kernel Based Virtual Machine (KVM).
 300
 301 @item [12]
 302 @url{http://www.greensocs.com/projects/QEMUSystemC},
 303 QEMU-SystemC, a hardware co-simulator.
 304
 305 @end table