QEMU is a FAST! processor emulator using dynamic translation to achieve good emulation speed.
QEMU has two operating modes:
QEMU can run without an host kernel driver and yet gives acceptable performance.
For system emulation, the following hardware targets are supported:
For user emulation, x86, PowerPC, ARM, MIPS, Sparc32/64 and ColdFire(m68k) CPUs are supported.
If you want to compile QEMU yourself, see section 6. Compilation from the sources.
If a precompiled package is available for your distribution - you just have to install it. Otherwise, see section 6. Compilation from the sources.
Download the experimental binary installer at http://www.free.oszoo.org/@/download.html.
Download the experimental binary installer at http://www.free.oszoo.org/@/download.html.
The QEMU PC System emulator simulates the following peripherals:
SMP is supported with up to 255 CPUs.
Note that adlib is only available when QEMU was configured with -enable-adlib
QEMU uses the PC BIOS from the Bochs project and the Plex86/Bochs LGPL VGA BIOS.
QEMU uses YM3812 emulation by Tatsuyuki Satoh.
Download and uncompress the linux image (`linux.img') and type:
qemu linux.img
Linux should boot and give you a prompt.
usage: qemu [options] [disk_image]
disk_image is a raw hard disk image for IDE hard disk 0.
General options:
-M ? for list)
fr for
French). This option is only needed where it is not easy to get raw PC
keycodes (e.g. on Macs, with some X11 servers or with a VNC
display). You don't normally need to use it on PC/Linux or PC/Windows
hosts.
The available layouts are:
ar de-ch es fo fr-ca hu ja mk no pt-br sv da en-gb et fr fr-ch is lt nl pl ru th de en-us fi fr-be hr it lv nl-be pt sl trThe default is
en-us.
qemu -soundhw sb16,adlib hda qemu -soundhw es1370 hda qemu -soundhw all hda qemu -soundhw ?
USB options:
Network options:
ne2k_pci, ne2k_isa, rtl8139,
smc91c111 and lance. Not all devices are supported on all
targets.
qemu linux.img -net nic -net tapMore complicated example (two NICs, each one connected to a TAP device)
qemu linux.img -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \
-net nic,vlan=1 -net tap,vlan=1,ifname=tap1
# launch a first QEMU instance
qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \
-net socket,listen=:1234
# connect the VLAN 0 of this instance to the VLAN 0
# of the first instance
qemu linux.img -net nic,macaddr=52:54:00:12:34:57 \
-net socket,connect=127.0.0.1:1234
# launch one QEMU instance
qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \
-net socket,mcast=230.0.0.1:1234
# launch another QEMU instance on same "bus"
qemu linux.img -net nic,macaddr=52:54:00:12:34:57 \
-net socket,mcast=230.0.0.1:1234
# launch yet another QEMU instance on same "bus"
qemu linux.img -net nic,macaddr=52:54:00:12:34:58 \
-net socket,mcast=230.0.0.1:1234
Example (User Mode Linux compat.):
# launch QEMU instance (note mcast address selected
# is UML's default)
qemu linux.img -net nic,macaddr=52:54:00:12:34:56 \
-net socket,mcast=239.192.168.1:1102
# launch UML
/path/to/linux ubd0=/path/to/root_fs eth0=mcast
bin of the Unix TFTP client). The host IP address on the guest is as
usual 10.0.2.2.
qemu -hda linux.img -boot n -tftp /path/to/tftp/files -bootp /pxelinux.0
10.0.2.4 smbservermust be added in the file `C:\WINDOWS\LMHOSTS' (for windows 9x/Me) or `C:\WINNT\SYSTEM32\DRIVERS\ETC\LMHOSTS' (Windows NT/2000). Then `dir' can be accessed in `\\smbserver\qemu'. Note that a SAMBA server must be installed on the host OS in `/usr/sbin/smbd'. QEMU was tested successfully with smbd version 2.2.7a from the Red Hat 9 and version 3.0.10-1.fc3 from Fedora Core 3.
# on the host qemu -redir tcp:6001::6000 [...] # this host xterm should open in the guest X11 server xterm -display :1To redirect telnet connections from host port 5555 to telnet port on the guest, use the following:
# on the host qemu -redir tcp:5555::23 [...] telnet localhost 5555Then when you use on the host
telnet localhost 5555, you
connect to the guest telnet server.
Linux boot specific: When using these options, you can use a given Linux kernel without installing it in the disk image. It can be useful for easier testing of various kernels.
Debug/Expert options:
vc in graphical mode and
stdio in non graphical mode.
This option can be used several times to simulate up to 4 serials
ports.
Use -serial none to disable all serial ports.
Available character devices are:
vc
pty
none
null
/dev/XXX
/dev/parportN
file:filename
stdio
pipe:filename
COMn
udp:[remote_host]:remote_port[@[src_ip]:src_port]
0.0.0.0. When not using a specifed src_port a random port is automatically chosen.
If you just want a simple readonly console you can use netcat or
nc, by starting qemu with: -serial udp::4555 and nc as:
nc -u -l -p 4555. Any time qemu writes something to that port it
will appear in the netconsole session.
If you plan to send characters back via netconsole or you want to stop
and start qemu a lot of times, you should have qemu use the same
source port each time by using something like -serial
udp::4555@:4556 to qemu. Another approach is to use a patched
version of netcat which can listen to a TCP port and send and receive
characters via udp. If you have a patched version of netcat which
activates telnet remote echo and single char transfer, then you can
use the following options to step up a netcat redirector to allow
telnet on port 5555 to access the qemu port.
Qemu Options:
netcat options:
telnet options:
tcp:[host]:port[,server][,nowait][,nodelay]
nowait
option was specified. The nodelay option disables the Nagle buffering
algoritm. If host is omitted, 0.0.0.0 is assumed. Only
one TCP connection at a time is accepted. You can use telnet to
connect to the corresponding character device.
Example to send tcp console to 192.168.0.2 port 4444
Example to listen and wait on port 4444 for connection
Example to not wait and listen on ip 192.168.0.100 port 4444
telnet:host:port[,server][,nowait][,nodelay]
-serial tcp. The
difference is that the port acts like a telnet server or client using
telnet option negotiation. This will also allow you to send the
MAGIC_SYSRQ sequence if you use a telnet that supports sending the break
sequence. Typically in unix telnet you do it with Control-] and then
type "send break" followed by pressing the enter key.
unix:path[,server][,nowait]
-serial tcp except the unix domain socket
path is used for connections.
mon:dev_string
-serial mon:telnet::4444,server,nowait
-parallel none to disable all parallel ports.
vc in graphical mode and stdio in
non graphical mode.
0x01 when using the
-nographic option. 0x01 is equal to pressing
Control-a. You can select a different character from the ascii
control keys where 1 through 26 map to Control-a through Control-z. For
instance you could use the either of the following to change the escape
character to Control-t.
-echr 0x14
-echr 20
loadvm in monitor)
During the graphical emulation, you can use the following keys:
In the virtual consoles, you can use Ctrl-Up, Ctrl-Down, Ctrl-PageUp and Ctrl-PageDown to move in the back log.
During emulation, if you are using the @option{-nographic} option, use Ctrl-a h to get terminal commands:
The QEMU monitor is used to give complex commands to the QEMU emulator. You can use it to:
The following commands are available:
info mice
info capture
h or w can be specified with the i format to
respectively select 16 or 32 bit code instruction size.
(qemu) x/10i $eip 0x90107063: ret 0x90107064: sti 0x90107065: lea 0x0(%esi,1),%esi 0x90107069: lea 0x0(%edi,1),%edi 0x90107070: ret 0x90107071: jmp 0x90107080 0x90107073: nop 0x90107074: nop 0x90107075: nop 0x90107076: nop
(qemu) xp/80hx 0xb8000 0x000b8000: 0x0b50 0x0b6c 0x0b65 0x0b78 0x0b38 0x0b36 0x0b2f 0x0b42 0x000b8010: 0x0b6f 0x0b63 0x0b68 0x0b73 0x0b20 0x0b56 0x0b47 0x0b41 0x000b8020: 0x0b42 0x0b69 0x0b6f 0x0b73 0x0b20 0x0b63 0x0b75 0x0b72 0x000b8030: 0x0b72 0x0b65 0x0b6e 0x0b74 0x0b2d 0x0b63 0x0b76 0x0b73 0x000b8040: 0x0b20 0x0b30 0x0b35 0x0b20 0x0b4e 0x0b6f 0x0b76 0x0b20 0x000b8050: 0x0b32 0x0b30 0x0b30 0x0b33 0x0720 0x0720 0x0720 0x0720 0x000b8060: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x000b8070: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x000b8080: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x000b8090: 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720 0x0720
- to press several keys
simultaneously. Example:
sendkey ctrl-alt-f1This command is useful to send keys that your graphical user interface intercepts at low level, such as
ctrl-alt-f1 in X Window.
bus.addr. Use the monitor
command info usb to see the devices you can remove.
The monitor understands integers expressions for every integer argument. You can use register names to get the value of specifics CPU registers by prefixing them with $.
Since version 0.6.1, QEMU supports many disk image formats, including growable disk images (their size increase as non empty sectors are written), compressed and encrypted disk images. Version 0.8.3 added the new qcow2 disk image format which is essential to support VM snapshots.
You can create a disk image with the command:
qemu-img create myimage.img mysize
where myimage.img is the disk image filename and mysize is its
size in kilobytes. You can add an M suffix to give the size in
megabytes and a G suffix for gigabytes.
See section 3.6.4 qemu-img Invocation for more information.
If you use the option @option{-snapshot}, all disk images are
considered as read only. When sectors in written, they are written in
a temporary file created in `/tmp'. You can however force the
write back to the raw disk images by using the commit monitor
command (or C-a s in the serial console).
VM snapshots are snapshots of the complete virtual machine including
CPU state, RAM, device state and the content of all the writable
disks. In order to use VM snapshots, you must have at least one non
removable and writable block device using the qcow2 disk image
format. Normally this device is the first virtual hard drive.
Use the monitor command savevm to create a new VM snapshot or
replace an existing one. A human readable name can be assigned to each
snapshot in addition to its numerical ID.
Use loadvm to restore a VM snapshot and delvm to remove
a VM snapshot. info snapshots lists the available snapshots
with their associated information:
(qemu) info snapshots Snapshot devices: hda Snapshot list (from hda): ID TAG VM SIZE DATE VM CLOCK 1 start 41M 2006-08-06 12:38:02 00:00:14.954 2 40M 2006-08-06 12:43:29 00:00:18.633 3 msys 40M 2006-08-06 12:44:04 00:00:23.514
A VM snapshot is made of a VM state info (its size is shown in
info snapshots) and a snapshot of every writable disk image.
The VM state info is stored in the first qcow2 non removable
and writable block device. The disk image snapshots are stored in
every disk image. The size of a snapshot in a disk image is difficult
to evaluate and is not shown by info snapshots because the
associated disk sectors are shared among all the snapshots to save
disk space (otherwise each snapshot would need a full copy of all the
disk images).
When using the (unrelated) -snapshot option
(section 3.6.2 Snapshot mode), you can always make VM snapshots,
but they are deleted as soon as you exit QEMU.
VM snapshots currently have the following known limitations:
qemu-img Invocationusage: qemu-img command [command options]
The following commands are supported:
Command parameters:
raw
qemu-img info to know the real size used by the
image or ls -ls on Unix/Linux.
qcow2
qcow
cow
vmdk
cloop
M
(megabyte) and G (gigabyte) are supported
Command description:
commit monitor command.
-e option) or compressed (-c option).
Only the format qcow supports encryption or compression. The
compression is read-only. It means that if a compressed sector is
rewritten, then it is rewritten as uncompressed data.
Encryption uses the AES format which is very secure (128 bit keys). Use
a long password (16 characters) to get maximum protection.
Image conversion is also useful to get smaller image when using a
growable format such as qcow or cow: the empty sectors
are detected and suppressed from the destination image.
In addition to disk image files, QEMU can directly access host devices. We describe here the usage for QEMU version >= 0.8.3.
On Linux, you can directly use the host device filename instead of a disk image filename provided you have enough proviledge to access it. For example, use `/dev/cdrom' to access to the CDROM or `/dev/fd0' for the floppy.
CD
Floppy
Hard disks
CD
change or eject monitor commands to
change or eject media.
Hard disks
`/dev/cdrom' is an alias to the first CDROM.
Currently there is no specific code to handle removable media, so it
is better to use the change or eject monitor commands to
change or eject media.
QEMU can automatically create a virtual FAT disk image from a directory tree. In order to use it, just type:
qemu linux.img -hdb fat:/my_directory
Then you access access to all the files in the `/my_directory' directory without having to copy them in a disk image or to export them via SAMBA or NFS. The default access is read-only.
Floppies can be emulated with the :floppy: option:
qemu linux.img -fda fat:floppy:/my_directory
A read/write support is available for testing (beta stage) with the
:rw: option:
qemu linux.img -fda fat:floppy:rw:/my_directory
What you should never do:
QEMU can simulate several networks cards (NE2000 boards on the PC target) and can connect them to an arbitrary number of Virtual Local Area Networks (VLANs). Host TAP devices can be connected to any QEMU VLAN. VLAN can be connected between separate instances of QEMU to simulate large networks. For simpler usage, a non priviledged user mode network stack can replace the TAP device to have a basic network connection.
QEMU simulates several VLANs. A VLAN can be symbolised as a virtual connection between several network devices. These devices can be for example QEMU virtual Ethernet cards or virtual Host ethernet devices (TAP devices).
This is the standard way to connect QEMU to a real network. QEMU adds
a virtual network device on your host (called tapN), and you
can then configure it as if it was a real ethernet card.
As an example, you can download the `linux-test-xxx.tar.gz'
archive and copy the script `qemu-ifup' in `/etc' and
configure properly sudo so that the command ifconfig
contained in `qemu-ifup' can be executed as root. You must verify
that your host kernel supports the TAP network interfaces: the
device `/dev/net/tun' must be present.
See section 3.3 Invocation to have examples of command lines using the TAP network interfaces.
There is a virtual ethernet driver for Windows 2000/XP systems, called TAP-Win32. But it is not included in standard QEMU for Windows, so you will need to get it separately. It is part of OpenVPN package, so download OpenVPN from : http://openvpn.net/.
By using the option @option{-net user} (default configuration if no @option{-net} option is specified), QEMU uses a completely user mode network stack (you don't need root priviledge to use the virtual network). The virtual network configuration is the following:
QEMU VLAN <------> Firewall/DHCP server <-----> Internet
| (10.0.2.2)
|
----> DNS server (10.0.2.3)
|
----> SMB server (10.0.2.4)
The QEMU VM behaves as if it was behind a firewall which blocks all incoming connections. You can use a DHCP client to automatically configure the network in the QEMU VM. The DHCP server assign addresses to the hosts starting from 10.0.2.15.
In order to check that the user mode network is working, you can ping the address 10.0.2.2 and verify that you got an address in the range 10.0.2.x from the QEMU virtual DHCP server.
Note that ping is not supported reliably to the internet as it
would require root priviledges. It means you can only ping the local
router (10.0.2.2).
When using the built-in TFTP server, the router is also the TFTP server.
When using the @option{-redir} option, TCP or UDP connections can be redirected from the host to the guest. It allows for example to redirect X11, telnet or SSH connections.
Using the @option{-net socket} option, it is possible to make VLANs that span several QEMU instances. See section 3.3 Invocation to have a basic example.
This section explains how to launch a Linux kernel inside QEMU without having to make a full bootable image. It is very useful for fast Linux kernel testing.
The syntax is:
qemu -kernel arch/i386/boot/bzImage -hda root-2.4.20.img -append "root=/dev/hda"
Use @option{-kernel} to provide the Linux kernel image and @option{-append} to give the kernel command line arguments. The @option{-initrd} option can be used to provide an INITRD image.
When using the direct Linux boot, a disk image for the first hard disk `hda' is required because its boot sector is used to launch the Linux kernel.
If you do not need graphical output, you can disable it and redirect the virtual serial port and the QEMU monitor to the console with the @option{-nographic} option. The typical command line is:
qemu -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \
-append "root=/dev/hda console=ttyS0" -nographic
Use Ctrl-a c to switch between the serial console and the monitor (see section 3.4 Keys).
QEMU emulates a PCI UHCI USB controller. You can virtually plug virtual USB devices or real host USB devices (experimental, works only on Linux hosts). Qemu will automatically create and connect virtual USB hubs as necessary to connect multiple USB devices.
USB devices can be connected with the @option{-usbdevice} commandline option
or the usb_add monitor command. Available devices are:
mouse
tablet
disk:file
host:bus.addr
host:vendor_id:product_id
WARNING: this is an experimental feature. QEMU will slow down when using it. USB devices requiring real time streaming (i.e. USB Video Cameras) are not supported yet.
ls /proc/bus/usb 001 devices drivers
chown -R myuid /proc/bus/usb
info usbhost
Device 1.2, speed 480 Mb/s
Class 00: USB device 1234:5678, USB DISK
You should see the list of the devices you can use (Never try to use
hubs, it won't work).
usb_add host:1234:5678Normally the guest OS should report that a new USB device is plugged. You can use the option @option{-usbdevice} to do the same.
When relaunching QEMU, you may have to unplug and plug again the USB device to make it work again (this is a bug).
QEMU has a primitive support to work with gdb, so that you can do 'Ctrl-C' while the virtual machine is running and inspect its state.
In order to use gdb, launch qemu with the '-s' option. It will wait for a gdb connection:
> qemu -s -kernel arch/i386/boot/bzImage -hda root-2.4.20.img \
-append "root=/dev/hda"
Connected to host network interface: tun0
Waiting gdb connection on port 1234
Then launch gdb on the 'vmlinux' executable:
> gdb vmlinux
In gdb, connect to QEMU:
(gdb) target remote localhost:1234
Then you can use gdb normally. For example, type 'c' to launch the kernel:
(gdb) c
Here are some useful tips in order to use gdb on system code:
info reg to display all the CPU registers.
x/10i $eip to display the code at the PC position.
set architecture i8086 to dump 16 bit code. Then use
x/10i $cs*16+$eip to dump the code at the PC position.
To have access to SVGA graphic modes under X11, use the vesa or
the cirrus X11 driver. For optimal performances, use 16 bit
color depth in the guest and the host OS.
When using a 2.6 guest Linux kernel, you should add the option
clock=pit on the kernel command line because the 2.6 Linux
kernels make very strict real time clock checks by default that QEMU
cannot simulate exactly.
When using a 2.6 guest Linux kernel, verify that the 4G/4G patch is not activated because QEMU is slower with this patch. The QEMU Accelerator Module is also much slower in this case. Earlier Fedora Core 3 Linux kernel (< 2.6.9-1.724_FC3) were known to incorporte this patch by default. Newer kernels don't have it.
If you have a slow host, using Windows 95 is better as it gives the best speed. Windows 2000 is also a good choice.
QEMU emulates a Cirrus Logic GD5446 Video card. All Windows versions starting from Windows 95 should recognize and use this graphic card. For optimal performances, use 16 bit color depth in the guest and the host OS.
If you are using Windows XP as guest OS and if you want to use high resolution modes which the Cirrus Logic BIOS does not support (i.e. >= 1280x1024x16), then you should use the VESA VBE virtual graphic card (option @option{-std-vga}).
Windows 9x does not correctly use the CPU HLT instruction. The result is that it takes host CPU cycles even when idle. You can install the utility from http://www.user.cityline.ru/~maxamn/amnhltm.zip to solve this problem. Note that no such tool is needed for NT, 2000 or XP.
Windows 2000 has a bug which gives a disk full problem during its installation. When installing it, use the @option{-win2k-hack} QEMU option to enable a specific workaround. After Windows 2000 is installed, you no longer need this option (this option slows down the IDE transfers).
Windows 2000 cannot automatically shutdown in QEMU although Windows 98 can. It comes from the fact that Windows 2000 does not automatically use the APM driver provided by the BIOS.
In order to correct that, do the following (thanks to Struan Bartlett): go to the Control Panel => Add/Remove Hardware & Next => Add/Troubleshoot a device => Add a new device & Next => No, select the hardware from a list & Next => NT Apm/Legacy Support & Next => Next (again) a few times. Now the driver is installed and Windows 2000 now correctly instructs QEMU to shutdown at the appropriate moment.
See section 3.3 Invocation about the help of the option @option{-smb}.
Some releases of Windows XP install correctly but give a security error when booting:
A problem is preventing Windows from accurately checking the license for this computer. Error code: 0x800703e6.
The workaround is to install a service pack for XP after a boot in safe mode. Then reboot, and the problem should go away. Since there is no network while in safe mode, its recommended to download the full installation of SP1 or SP2 and transfer that via an ISO or using the vvfat block device ("-hdb fat:directory_which_holds_the_SP").
DOS does not correctly use the CPU HLT instruction. The result is that it takes host CPU cycles even when idle. You can install the utility from http://www.vmware.com/software/dosidle210.zip to solve this problem.
QEMU is a generic emulator and it emulates many non PC machines. Most of the options are similar to the PC emulator. The differences are mentionned in the following sections.
Use the executable `qemu-system-ppc' to simulate a complete PREP or PowerMac PowerPC system.
QEMU emulates the following PowerMac peripherals:
QEMU emulates the following PREP peripherals:
QEMU uses the Open Hack'Ware Open Firmware Compatible BIOS available at http://perso.magic.fr/l_indien/OpenHackWare/index.htm.
The following options are specific to the PowerPC emulation:
More information is available at http://perso.magic.fr/l_indien/qemu-ppc/.
Use the executable `qemu-system-sparc' to simulate a SparcStation 5 (sun4m architecture). The emulation is somewhat complete.
QEMU emulates the following sun4m peripherals:
The number of peripherals is fixed in the architecture.
Since version 0.8.2, QEMU uses OpenBIOS http://www.openbios.org/. OpenBIOS is a free (GPL v2) portable firmware implementation. The goal is to implement a 100% IEEE 1275-1994 (referred to as Open Firmware) compliant firmware.
A sample Linux 2.6 series kernel and ram disk image are available on the QEMU web site. Please note that currently NetBSD, OpenBSD or Solaris kernels don't work.
The following options are specific to the Sparc emulation:
Use the executable `qemu-system-sparc64' to simulate a Sun4u machine. The emulator is not usable for anything yet.
QEMU emulates the following sun4u peripherals:
Use the executable `qemu-system-mips' to simulate a MIPS machine. The emulator is able to boot a Linux kernel and to run a Linux Debian installation from NFS. The following devices are emulated:
More information is available in the QEMU mailing-list archive.
Use the executable `qemu-system-arm' to simulate a ARM machine. The ARM Integrator/CP board is emulated with the following devices:
The ARM Versatile baseboard is emulated with the following devices:
The ARM RealView Emulation baseboard is emulated with the following devices:
A Linux 2.6 test image is available on the QEMU web site. More information is available in the QEMU mailing-list archive.
The following OS are supported in user space emulation:
In order to launch a Linux process, QEMU needs the process executable itself and all the target (x86) dynamic libraries used by it.
qemu-i386 -L / /bin/ls
-L / tells that the x86 dynamic linker must be searched with a
`/' prefix.
qemu-i386 -L / qemu-i386 -L / /bin/ls
LD_LIBRARY_PATH is not set:
unset LD_LIBRARY_PATHThen you can launch the precompiled `ls' x86 executable:
qemu-i386 tests/i386/lsYou can look at `qemu-binfmt-conf.sh' so that QEMU is automatically launched by the Linux kernel when you try to launch x86 executables. It requires the
binfmt_misc module in the
Linux kernel.
qemu-i386 /usr/local/qemu-i386/bin/qemu-i386 \
/usr/local/qemu-i386/bin/ls-i386
qemu-i386 /usr/local/qemu-i386/bin/ls-i386
${HOME}/.wine directory is saved to ${HOME}/.wine.org.
qemu-i386 /usr/local/qemu-i386/wine/bin/wine \
/usr/local/qemu-i386/wine/c/Program\ Files/putty.exe
usage: qemu-i386 [-h] [-d] [-L path] [-s size] program [arguments...]
Debug options:
@command{qemu-arm} is also capable of running ARM "Angel" semihosted ELF binaries (as implemented by the arm-elf and arm-eabi Newlib/GDB configurations), and arm-uclinux bFLT format binaries.
@command{qemu-m68k} is capable of running semihosted binaries using the BDM (m5xxx-ram-hosted.ld) or m68k-sim (sim.ld) syscall interfaces, and coldfire uClinux bFLT format binaries.
The binary format is detected automatically.
[1] If you're host commpage can be executed by qemu.
In order to launch a Mac OS X/Darwin process, QEMU needs the process executable itself and all the target dynamic libraries used by it. If you don't have the FAT libraries (you're running Mac OS X/ppc) you'll need to obtain it from a Mac OS X CD or compile them by hand.
qemu-i386 /bin/lsor to run the ppc version of the executable:
qemu-ppc /bin/ls
qemu-i386 -L /opt/x86_root/ /bin/ls
-L /opt/x86_root/ tells that the dynamic linker (dyld) path is in
`/opt/x86_root/usr/bin/dyld'.
usage: qemu-i386 [-h] [-d] [-L path] [-s size] program [arguments...]
Debug options:
First you must decompress the sources:
cd /tmp tar zxvf qemu-x.y.z.tar.gz cd qemu-x.y.z
Then you configure QEMU and build it (usually no options are needed):
./configure make
Then type as root user:
make install
to install QEMU in `/usr/local'.
In order to compile QEMU successfully, it is very important that you
have the right tools. The most important one is gcc. On most hosts and
in particular on x86 ones, gcc 4.x is not supported. If your
Linux distribution includes a gcc 4.x compiler, you can usually
install an older version (it is invoked by gcc32 or
gcc34). The QEMU configure script automatically probes for
these older versions so that usally you don't have to do anything.
./configure --enable-mingw32If necessary, you can change the cross-prefix according to the prefix choosen for the MinGW tools with --cross-prefix. You can also use --prefix to set the Win32 install path.
Note: Currently, Wine does not seem able to launch QEMU for Win32.
The Mac OS X patches are not fully merged in QEMU, so you should look at the QEMU mailing list archive to have all the necessary information.
Jump to:
This document was generated on 4 May 2007 using texi2html 1.56k.