[[Vorlage(Getestet, jammy)]] {{{#!vorlage Wissen [:Pakete_installieren: Installation von Programmen] [:Paketquellen_freischalten: Bearbeiten von Paketquellen] [:Terminal: Ein Terminal öffnen] [:Editor: Einen Editor öffnen] [:Kernelmodule: Umgang mit Kernelmodulen (Treibern)] }}} [[Inhaltsverzeichnis(3)]] [http://wiki.qemu.org/Main_Page QEMU] {en} ist ein freier [wikipedia:Emulator:] und Virtualisierer. Mit ihm ist es möglich, ein anderes Betriebssystem unter Linux zu booten, die Ausgaben in einem Fenster anzuzeigen, und es dann so zu benutzen, als sei es nativ auf einem Rechner gestartet worden. Eine grundsätzliche Einführung zu diesem Thema findet man im Artikel [:Virtualisierung:]. Einige Merkmale von QEMU sind: * läuft in Kombination mit [:KVM:] als Hypervisor mit fast nativer Geschwindigkeit * kann auch andere Prozessorarchitekturen wie z.B. PowerPC oder ARM emulieren * kann verschiedene Arten von Laufwerken emulieren und einbinden * sehr viele [#Optionen Optionen] zum Starten des Gastsystems, wie z.B. Multiprozessor-Emulation auch bei Einprozessor-Systemen QEMU ist auch für [https://www.qemu.org/download/ andere Plattformen] {en} wie Windows und MacOS erhältlich. = Installation = Im Paket von QEMU ist auch [:KVM:] enthalten; es kann durch folgendes Paket installiert [1] werden: {{{#!vorlage Paketinstallation qemu-system-x86 }}} Dieses Paket unterstützt nur Gastsysteme mit x86-Architektur (32- und 64-Bit). Möchte man andere Hardware-Plattformen emulieren, kann man die Unterstützung von anderen Systemen mit dem Paket '''qemu-system''' installieren. Es handelt sich dabei um ein Meta-Paket, dass die Pakete für alle verfügbaren Zielsysteme installiert. {{{#!vorlage Paketinstallation qemu-system }}} == Symlink == Danach kann noch eine Verknüpfung auf die gewünschte Standard-Systemarchitektur (typischerweise `i386` bzw. `x86_64`) gesetzt werden: {{{#!vorlage Befehl sudo ln -s /usr/bin/qemu-system-ARCHITEKTUR /usr/bin/qemu }}} `ARCHITEKTUR` ist dabei durch die gewünschte Prozessorarchitektur zu ersetzen. == QEMU User Mode == Wenn man nur den [:QEMU/#Reine-Prozessemulation:QEMU User Mode] installieren möchte: {{{#!vorlage Paketinstallation qemu-user }}} == Hypervisor und Emulator == Laufen Host- und Gastsystem auf der gleichen Rechnerarchitektur (z.B. x86_64), kann QEMU durch das mitinstallierte KVM als Hypervisor arbeiten. Dann läuft der Gast direkt auf dem Prozessor des Host und ist damit ähnlich schnell, wie eine native Installation. Wie man herausfindet, ob der Host diese Hardwarevirtualisierung unterstützt, wird im Artikel [:KVM:] beschrieben. Bei Gastsystemen, die auf einer anderen Rechnerarchitektur laufen, emuliert QEMU die Zielarchitektur. Dadurch wird die Geschwindigkeit des Gast gegenüber einem nativen System deutlich reduziert. = Grafische Oberflächen und Kommandozeilentools für QEMU = Dieser Artikel beschreibt ausschließlich die Einrichtung und Startparameter für QEMU direkt über ein Terminal[3]. Der Vollständigkeit halber seien hier aber noch einige grafische Programme für QEMU aufgeführt, die den Einstieg in QEMU wesentlich erleichtern. Sie sind nach den verwendeten graphischen Toolkits sortiert. * [:GTK:]: * '''[:virt-manager:]''' - das Standardtool für QEMU/KVM-Virtualisierung, baut auf [https://libvirt.org/ libvirt] auf * [https://wiki.gnome.org/Apps/Boxes Boxes] {en} - ein vereinfachte Variante für Gnome, baut auf [https://libvirt.org/ libvirt] auf * [:QT:]: * '''[:AQEMU:]''' * [:Shell:]: * '''[:virsh:]''' - das Kommandozeilentool für [https://libvirt.org/ libvirt] [[Bild(Wiki/Icons/develop.png,50,right)]] [[Bild(Wiki/Icons/download_manager.png,50,right)]] = Installation eines Gastbetriebssystems = Alle folgenden Befehle werden in einem Terminal [3] eingegeben. == Virtuelle Festplatte einrichten == Um ein Betriebssystem in einer Virtuellen Maschine installieren zu können, muss als erstes eine virtuelle Festplatte als Datei erstellt werden: {{{#!vorlage Befehl qemu-img create BOOTSYSTEM.img 10G }}} Anstatt `BOOTSYSTEM` sollte man einen geeigneten Namen wählen. In diesem Fall erstellt man ein 10 GB großes Festplattenimage im raw-Format. Man kann die Größe des Image auch in MiB angeben, also bezogen auf das obige Beispiel `10240M` (10 * 1024) statt `10G`. Je nachdem, in welcher Art von [:Dateisystem:] dieses Image liegt, wächst die Datei ggf. erst dann dynamisch an, wenn tatsächlich Daten darin gespeichert werden. Damit ist sie anfangs 0 Bytes groß, auch wenn die meisten Programme (z.B.) 10 GiB zeigen. Dies ist z.B. bei einer typischen Ubuntu-Installation auf einem [:ext:]-Dateisystem der Fall (bezogen auf das Host-System; der Gast in der VM ist egal). Möchte man solche [wikipedia:Sparse-Datei:Sparse-Dateien] auch auf älteren Dateisystemen nutzen oder andere Verbesserungen nutzen, so kann man ein anderes Format wie `qed` oder `qcow2` angeben: {{{#!vorlage Befehl qemu-img create -f qcow2 BOOTSYSTEM.img 10G }}} == Installation von CD oder CD-Image == Wenn das Festplattenimage erstellt ist, kann man nun ein Betriebssystem darin installieren. Es sollte dabei von vornherein bedacht werden, welche Arbeitsspeicher-Anforderungen (RAM) das zu installierende System hat. Entsprechend wird QEMU mit der Option `-m SPEICHERGRÖSSE` gestartet. Richtwerte können der Tabelle in [:Virtualisierung#Gastsystem: Gastsystem] entnommen werden. Start des Installationsvorgangs mittels CD-ROM-Laufwerk, es wird dem Gastsystem 2048 MiB Speicher zur Verfügung gestellt: {{{#!vorlage Befehl qemu-system-ARCHITEKTUR -enable-kvm -hda BOOTSYSTEM.img -cdrom /dev/cdrom -boot d -m 2048 }}} Das `-boot d` bedeutet, dass QEMU von CD-ROM booten soll. Wenn die Installations-CD als ISO-Image vorliegt, geht das analog dazu: {{{#!vorlage Befehl qemu-system-ARCHITEKTUR -enable-kvm -hda BOOTSYSTEM.img -cdrom DATEINAME.iso -boot d -m 2048 }}} Bei ARCHITEKTUR ist die festgelegte Standard-Architektur einzufügen (für AMD64 lautet der Befehl beispielsweise `qemu-system-x86_64`) Nach erfolgreicher Installation muss die Option `-boot d` weggelassen werden, damit anstatt vom CD-ROM-Laufwerk von der virtuellen Festplatte gebootet wird. Ein ISO-Abbild (Abbild-Datei) beispielsweise einer Installations-DVD von Windows kann man mit einem [:Brennprogramme:Brennprogramm] erstellen. QEMU kommt mit ISO-Images besser zurecht als mit DVDs. == Overlay-Images anlegen == QEMU bietet die Möglichkeit, mit Overlay-Dateien (übersetzt: "Überlagerungsdateien") zu arbeiten. Dabei werden neue und geänderte Daten nicht in die Original Imagedatei sondern in die Overlay-Datei geschrieben. Das original Image bleibt unverändert. Diese ist z.B. dann praktisch, wenn man eine "saubere" Grundinstallation eines Systems hat und "Experimente" mit dem Overlay-Image gemacht werden, welche sich nicht auf das Original auswirken. Ebenso kann man mehrere Overlays für ein Image anlegen. Um ein Overlay-Image anzulegen dient folgender Befehl: {{{#!vorlage Befehl qemu-img create -b mein_image.img -F -f qcow2 mein_overlay.ovl }}} Der Name der Overlay-Datei kann dabei beliebig sein und muss nichts mit den Namen des Images zu tun haben. Danach kann man die virtuelle Maschine normal booten, nur dass anstatt des Images die Overlay-Datei als Festplatte angegeben werden muss, also z.B. {{{#!vorlage Befehl qemu -hda mein_overlay.ovl }}} {{{#!vorlage Hinweis Die Overlay-Dateien sind "Delta-Images", d.h. in der Overlay-Datei werden Änderungen relativ zum Original Image gespeichert. Ändert man das zugrunde liegende Image, nachdem eine Overlay-Datei angelegt wurde, funktioniert die Overlay-Datei nicht mehr! }}} Es ist auch möglich, Änderungen der Overlay-Datei ins zugrunde liegende Image zu schreiben. == Festplatten von Virtualbox in QEMU nutzen== Für den Fall, dass man bereits existierende virtuelle Festplatten im [:VirtualBox:]-Format '''.vdi''' nutzt, kann man diese für QEMU nutzbar machen. {{{#!vorlage Befehl VBoxManage clonehd /pfad/zur/virtualbox_platte/system.vdi /pfad/zur/kvm_platte/system.img --format raw }}} Je nach Größe des Abbildes kann die Konvertierung einige Zeit in Anspruch nehmen. == Vollständige Kommandozeile zum Starten von QEMU == Eine beispielhafte, vollständige Kommandozeile zum Starten eines Lubuntu-Image: {{{#!vorlage Befehl qemu-system-x86_64 \ -enable-kvm \ -cpu host \ -machine q35 \ -device amd-iommu \ -m 4096 \ -smp 4 \ -device virtio-vga-gl -display sdl,gl=on \ -device intel-hda -device hda-duplex \ -device virtio-serial -chardev spicevmc,id=vdagent,debug=0,name=vdagent \ -device virtserialport,chardev=vdagent,name=com.redhat.spice.0 \ -hda lubuntu/lubuntu22.04.qcow2 \ -name "Lubuntu 22.04" }}} [[Bild(Wiki/Icons/globe.png,50,right)]] = QEMU Umgebung = Während das Betriebssystem installiert wird, sollte man sich mit der Umgebung von QEMU etwas vertraut machen. == Tastenkombinationen == ||<-2 tableclass="zebra_start3"; rowclass="titel" :>Tastenkombination von QEMU|| ||Tasten||Erklärung|| ||[[Vorlage(Tasten, Strg+Alt)]]||Maus aus dem QEMU-Fenster befreien|| ||[[Vorlage(Tasten, Strg+Alt+2)]]||vom Gast in den [#QEMU-Monitor QEMU-Monitor] wechseln|| ||[[Vorlage(Tasten, Strg+Alt+1)]]||vom QEMU-Monitor ins Gast-Betriebssystem wechseln|| ||[[Vorlage(Tasten, Strg+Alt+f)]]||zwischen Fenster- und Vollbildmodus wechseln|| == QEMU-Monitor == Der Monitor von QEMU (manchmal auch QEMU-Konsole genannt) bietet eine Reihe von Möglichkeiten zur Verwaltung und Steuerung der virtuellen Maschine. So kann hierüber auch der Wechsel von CD-ROM-Medien oder Disketten erfolgen. Einige davon sind: ||<-2 tableclass="zebra_start3" rowclass="titel" :>Befehle für den QEMU-Monitor|| ||Befehl||Erklärung|| ||`info GERÄT`||gibt Infos über das virtuelle Gerät aus; mögliche Geräte sind u.a. `block` (Festplatte[n], CD-ROM), `snapshot`, `usb` und `network`|| || `change GERÄT GERÄTEDATEI` || Tauscht ein Wechselmedium (CD/DVD, Diskette) aus (siehe: [#Wechseldatentraeger Wechseldatenträger]) || ||`commit`||schreibt einen Snapshot, sofern QEMU mit der Option `-snapshot` gestartet wurde|| ||`screendump DATEI`||erstellt ein Bildschirmfoto, wobei das recht ungewöhnliche Dateiformat '''ppm''' verwendet wird. Beispiel: `screendump BILDNAME.ppm`|| ||`sendkey ctrl-alt-f1`||sendet die Tastenkombination [[Vorlage(Tasten, STRG)]] + [[Vorlage(Tasten, ALT)]] + [[Vorlage(Tasten, F1)]] an das Gastsystem (ruft in einem Ubuntu-Gast die [:Terminal#Virtuelle-Konsole:virtuelle Konsole] auf)|| ||`help [befehl]`||zeigt eine Hilfe für alle Befehle oder nur für den Befehl `befehl`|| === Wechseldatenträger === QEMU kann während der Virtualisierung nicht automatisch feststellen, ob eine CD oder Diskette eingelegt oder gewechselt wurde. Dies wird über den QEMU-Monitor erledigt. Im QEMU-Monitor erkundigt man sich über den Befehl `info block` zuerst, welche Geräte angeschlossen sind und wie sie heißen: {{{#!vorlage Befehl info block ide1-cd0: type=cdrom removable=1 locked=0 file=/dev/cdrom ro=0 drv=host_cdrom encrypted=0 ide0-hd0: type=hd removable=0 file=/PFAD/ZUM/CONTAINER.img ro=0 drv=qcow2 encrypted=0 ... }}} In diesem Beispiel heißt das CD-ROM-Gerät `ide1-cd0` und die Gerätedatei '''/dev/cdrom'''. Entsprechend wird QEMU durch die Eingabe von {{{#!vorlage Befehl change ide1-cd0 /dev/cdrom }}} mitgeteilt, dass eine CD eingelegt/gewechselt wurde, und man kann mit dem Gastsystem darauf zugreifen. Bei dem Wechsel von Disketten müssen die Optionen entsprechend angepasst werden. = Bildschirmausgabe = == Grafikkarten == Die Standardgrafikkarte unter QEMU ist vga-std. Diese kann vom Gastbetriebssystem ohne weitere Treiber verwendet werden. {{{#!vorlage Tabelle Grafikkarte Option Eigenschaften +++ std -vga std Standard VGA-Grafikkarte, Option muss nicht angegeben werden +++ qxl -vga qxl oder -device qxl-vga Paravirtualisierte Grafikkarte, wird für SPICE benötigt +++ virtio -device virtio-vga-gl und -display sdl,gl=on oder -display gtk,gl=on Paravirtualisierte Grafikkarte, kann auch 3D-Grafikbeschleunigung +++ vnc -vnc :0 Grafikausgabe über VNC +++ keine -nographic Es wird nur eine Textkonsole bereitgestellt }}} == VNC == Möchte man die virtuelle Maschine von einem anderen Rechner aus bedienen, kann man die graphische Ausgabe des Gasts über VNC laufen lassen. Dazu muss man statt einer Grafikkarte die Option ``-vnc X`` angeben, wobei ``X`` das Display ist. Startet man QEMU also z.B. über {{{#!vorlage Befehl qemu -hda image.img -vnc :1 }}} so ist die virtuelle Maschine danach über einen [:VNC#Viewer:VNC-Viewer] via Port 5901 (5900 + Displaynummer) erreichbar. {{{#!vorlage Warnung Die Verbindung läuft per Voreinstellung komplett unverschlüsselt und ohne Authentifizierung. Falls es für den Einsatz notwendig ist, müssen dringend Sicherheitsvorkehrungen getroffen werden. Details hierzu findet man an [https://qemu-project.gitlab.io/qemu/system/vnc-security.html dieser Stelle] {en} auf der QEMU-Dokumentation. }}} == SPICE == [https://www.spice-space.org/ SPICE] {en} ähnelt den Gasterweiterungen in VirtualBox oder den VMware Tools. Über SPICE kann man z.B. die Auflösung des Gastes an die Fenstergröße im Host anpassen und eine gemeinsame Zwischenablage von Host und Gast ermöglichen. === Spice auf dem Host einschalten === Es müssen die folgenden Parameter an qemu übergeben werden: {{{#!vorlage Befehl qemu-system-x86_64 \ -device qxl-vga,vgamem_mb=32 \ -spice port=3001,password=MeinGeheimesPasswort \ -device virtio-serial -chardev spicevmc,id=vdagent,debug=0,name=vdagent \ -device virtserialport,chardev=vdagent,name=com.redhat.spice.0 }}} Für Remote-Verbindungen über den Port muss die Grafikkarte qxl verwendet werden. Für Auflösungen höher als 2560x1440 muss die Grafikkartenspeicher mit der Option vgamem_mb erhöht werden. Außerdem wird eine serielle Schnittstelle zwischen Host und Gast eingerichtet, über die die SPICE-Treiber auf dem Gast mit QEMU kommunizieren können. Wenn man keine Netzwerkverbindung zwischen Viewer und VM benötigt, kann man auch einen teilweise schnelleren Unix-Domain-Socket statt dem IP-Port verwenden: {{{ # Verbindung über Port 3001 -spice port=3001,password=MeinGeheimesPasswort # Verbindung über Unix-Domain-Socket run/user/$UID/spice.sock -spice unix=on,addr=/run/user/$UID/spice.sock,password=MeinGeheimesPasswort }}} {{{#!vorlage Tabelle Auflösung Mindestgröße Grafikkartenspeicher +++ 1920x1080, FullHD 8MB, Standardeinstellung reicht +++ 2560x1440 16MB, Standardeinstellung reicht +++ 3840x2160, 4k 32MB }}} Soll 3D-Beschleunigung aktiviert sein, muss Spice über einen lokalen Unix-Socket laufen. Dann kann man als Grafikkarte virtio einstellen. Leider funktioniert das aber nicht mit allen Systemen. {{{ -device virtio-vga-gl \ -spice unix=on,addr=/run/user/$UID/spice.sock,password=MeinGeheimesPasswort,gl=on \ }}} {{{#!vorlage Warnung Das Passwort in der Option "password=MeinGeheimesPasswort" muss durch ein eigenes, sicheres Passwort ersetzt werden. Es ist außerdem nicht sehr sicher, das Passwort über die Kommandozeile zu übergeben. Bessere Methoden kann man im [https://www.spice-space.org/spice-user-manual.html#spice-server Spice user manual] {en} nachlesen. Dort findet man auch Methoden, die Verbindung zu verschlüsseln, falls dies für den Einsatzzweck notwendig ist. }}} === Spice auf dem Gast einschalten === Es wird das Paket spice-vdagent und der qxl-Grafiktreiber benötigt. Unter Ubuntu müssen diese Pakete installiert sein: {{{#!vorlage Paketinstallation spice-vdagent xserver-xorg-video-qxl }}} Bei Problemen kann geprüft werden, ob der spice-vdagent Daemon läuft. === Über Spice mit dem Gast verbinden === Der von den Spice-Entwicklern empfohlene Spice-Client ist '''remote-viewer'''. {{{#!vorlage Paketinstallation virt-viewer }}} Aufgerufen wird er über {{{#!vorlage Befehl # Über Netzwerk remote-viewer spice://localhost:3001 # Über Unix-Socket remote-viewer spice+unix:///run/user/$UID/spice.sock }}} = Audio = Als Soundkarte kann z.B. IntelHD verwendet werden: {{{#!vorlage Befehl qemu-system-x86_64 -device intel-hda -device hda-duplex }}} Verfügbare (Audio-)Geräte kann man sich anzeigen lassen über {{{#!vorlage Befehl qemu-system-x86_64 -device help }}} = Netzwerk = In QEMU gibt es verschiedene Möglichkeiten, ein Netzwerk für die virtuellen Maschinen aufzusetzen. == User Network == Die einfachste Variante ist das "User Network", bei dem jede VM in einem eigenen Netzwerksegment liegt. Die einzelnen Netzwerksegmente sind über NAT mit dem Hostnetzwerk verbunden. '''Kommunikation Host - Gast''' Der Host ist von einem Gastsystem über seine normale IP-Adresse (geroutet) und über die IP-Adresse 10.0.2.2 (QEMU-interner Router) erreichbar. Um den Gast vom Host aus zu erreichen, muss eine Portweiterleitung konfiguriert werden. '''Kommunikation Gast - Gast''' Die einzelnen virtuellen Maschinen liegen in unterschiedlichen Netzwerksegmenten. Damit sie miteinander kommunizieren können, ist eine Portweiterleitung notwendig '''DHCP''' Hat man sein Netzwerk per [wikipedia:DHCP:] konfiguriert, sollten Internet und Netzwerk automatisch funktionieren. == TAP Netzwerk == Mit TAP wird im Host eine virtuelle Netzwerkkarte angelegt, die mit dem Gast verbunden ist. Dadurch können Gast und Host ohne Portweiterleitung miteinander kommunizieren. Damit die einzelnen virtuellen Maschinen miteinander kommunizieren können, muss noch eine Netzwerkbrücke im Host angelegt werden. Anlegen eines TAP mit dem [:NetworkManager:]: {{{#!vorlage Befehl nmcli connection add type tun ifname tap0 con-name tap0 mode tap owner `id -u` }}} In QEMU wird das TAP mit diesen Parametern konfiguriert: {{{ -netdev tap,id=tap0,ifname=tap0,script=no,downscript=no -device e1000,netdev=tap0,mac=52:54:00:12:34:56 }}} Für jede VM muss eine andere MAC-Adresse eingestellt werden. Man kann dann dem TAP Device auf der Host- und der Client-Seite statische IP-Adressen zuweisen, um direkt in beide Richtungen kommunizieren zu können. Möchte man mehrere VM miteinander verbinden und eventuell auch einen Internetzugang über den Host ermöglichen, muss man noch eine Netzwerkbrücke anlegen. === Netzwerkbrücke === Damit die einzelnen virtuellen Maschinen miteinander kommunizieren können, müssen die TAP-Netzwerke noch über eine [:Netzwerkbrücke:Netzwerkbrücke] verbunden werden. Wenn man die Brücke auch mit der Netzwerkkarte des Hosts verbindet, haben die virtuellen Maschinen Zugriff auf das Netzwerk des Hosts, also typischerweise auch Internetzugriff. Die Netzwerkbrücke für Ethernet lässt sich __nicht__ direkt mit einer WLAN-Schnittstelle verbinden; man muss dafür auf IP-Ebene routen. {{{#!vorlage Experten Andere VMM-Lösungen scheinen eine Art Brücke zu WLAN-Karten zu erzeugen, indem sie NAT auf MAC-Ebene durchführen. Es gibt Beschreibungen im Internet, wie man dies mit ebtables erreichen kann, siehe z.B. [https://wiki.debian.org/BridgeNetworkConnections#Bridging_with_a_wireless_NIC]{en} (ungetestet). }}} Der einfachste Weg, um die Brücke mit der WLAN-Karte des Host zu verbinden, ist [:Router/NAT:NAT]. In diesem Fall bleiben die QEMU-Gäste in ihrem eigenen Netzwerksegment und werden über die normale Internetverbindung des Hosts geroutet. === Routing === Möchte man Zugriff auf das Host-Netzwerk, ohne die Brücke direkt mit der echten Netzwerkkarte zu verbinden, kann man das Netzwerk stattdessen über die IP-Ebene routen, siehe [:Router/Routing-Funktion:Routing-Funktion]. [[Bild(Wiki/Icons/home.png,50,right)]] = Datenaustausch zwischen Host und Gast = Da Host und Gast durch QEMU voneinander isoliert sind, können diese nicht einfach auf die Daten des anderen zugreifen. Für den Datenaustausch gibt es verschiedene Möglichkeiten. == SSH == Vom Host lässt sich eine [:SSH#Dateitransfer:ssh]-Verbindung zum Gast aufbauen, wenn diese über ein TAP-Netzwerk verbunden sind, oder eine Portweiterleitung eingerichtet wurde. Auf dem Gastsystem muss dazu ein [:SSH#Der-SSH-Server:SSH-Server] laufen. === Einzelne Dateien per scp === {{{#!vorlage Befehl # Host sendet an Gast scp [-P port] datei1 datei2 :/Zielpfad/ # Host liest von Gast scp [-P port] :/Pfad/datei1 /Zielpfad_Host }}} === Ordner mit sshfs === Mit [:FUSE/sshfs:sshfs] lassen sich ganze Ordner über ssh einbinden. == Einzelne Dateien per netcat == Um einzelne Dateien auszutauschen, kann man die Tools [:tar:] und `nc` nutzen, sofern diese in Host und Gastsystem zur Verfügung stehen (z.B. beides Linux). Dazu führt man jeweils einen Befehl in einem Terminal [3] aus: {{{#!vorlage Befehl # Host sendet an Gast tar c DATEIEN | nc -v -l 8080 # auf dem Host nc 10.0.2.2 8080 | tar x # auf dem Gast # Gast sendet an Host nc -v -l 8080 | tar x # auf dem Host tar c DATEIEN | nc 10.0.2.2 8080 # auf dem Gast }}} == Partitions-Abbild == Per [:dd:] können ganze Partitionen in eine '''.img'''-Datei kopiert und als zweite Festplatte in QEMU eingebunden werden: {{{#!vorlage Befehl qemu -hda BOOTSYSTEM.img -hdb PFAD/ZUR/PARTITIONSKOPIE.img -m 2048 }}} == Ausgesuchte Daten in einer Iso-Datei == Mit einem [:Brennprogramme:Brennprogramm] können Verzeichnisse und Daten von verschiedenen Partitionen in einer ISO-Datei abgespeichert werden. Diese lässt sich als CD-ROM in QEMU einbinden: {{{#!vorlage Befehl qemu -hda BOOTSYSTEM.img -cdrom PFAD/ZUR/ISODATEI.iso -m 2048 }}} == Per Samba == Ist im Host-System ein [:Samba:Sambaserver] installiert, kann man mit QEMU auch auf dessen Freigaben per Netzwerk zugreifen: 1. Beim Aufruf von QEMU muss zusätzlich die Option `-nic user,smb=/path/to/local/dir` verwendet werden: \\ {{{#!vorlage Befehl qemu -hda BOOTSYSTEM.img -m 2048 -nic user,smb=/path/to/local/dir/ }}} QEMU startet den Samba-Server automatisch mit einer angepassten Konfiguration. 1. Der Zugriff vom Gast erfolgt über die URL `10.0.2.4` im Verzeichnis qemu: 1. Windows: In der Adressleiste (z.B. vom Arbeitsplatz) einfach die URL `\\10.0.2.4\qemu` eingeben 1. Ubuntu GUI: In der Adressleiste (z.B. von [:Nautilus:] oder [:Dolphin:]) einfach die URL `smb://10.0.2.4/qemu` eingeben 1. Ubuntu Konsole: smbclient //10.0.2.4/qemu \\ {{{#!vorlage Tabelle <:>[[Bild(samba_win.png, x100)]] <:>[[Bild(samba_ubuntu.png, x100)]] +++ <:>Windows <:>Ubuntu }}} [[Bild(Wiki/Icons/settings.png, 50, right)]] = Optionen = == Startoptionen == Unter den zahlreichen Startoptionen können besonders folgende nützlich sein: ||<-2 tableclass="zebra_start3" rowclass="titel" :> Ausgewählte Optionen von QEMU || || Option||Erklärung || || ``-hda Datei`` || gibt das Image der primären Festplatte an. Weitere Platten können mit `-hdb`, `-hdc` und `-hdd` angegeben werden || || ``-fda Datei`` || gibt Diskettenlaufwerke an. Man kann das reale Diskettenlaufwerk verwenden, wenn man ``/dev/fd0`` als Dateiname angibt || || ``-cdrom Datei`` || gibt das zu verwendende CD-Laufwerk an. Es kann ein Gerät wie '''/dev/cdrom''' oder eine Imagedatei angegeben werden || || ``-daemonize`` || löst den QEMU-Prozess vom Terminal; das Terminal kann nach dem Start ohne Beeinträchtigung geschlossen werden || || ``-boot Laufwerksbuchstabe`` || gibt an, von welchem Laufwerk gestartet werden soll. ``a`` steht für Diskette, ``c`` für Festplatte, ``d`` für CD-ROM und ``n`` für einen Netzwerk-Boot || || ``-m Speichergröße`` || gibt den zu verwendenden Arbeitsspeicher in MiB an. Vorbereitung dazu s.o. || || ``-usb``|| USB wird mit emuliert bzw. die Schnittstellen des Wirts stehen zur Verfügung. Mit `-usb -usbdevice tablet` kann der Mauszeiger sowohl im Gast- als auch im Host-System genutzt werden, ohne ständig mit [[Vorlage(Tasten, Strg+Alt)]] umschalten zu müssen || || ``-vga qxl`` || es wird ein paravirtualisierter Grafiktreiber verwendet. Benötigt einen passenden Treiber im Gast. || || ``-soundhw KARTE`` || es wird die Soundkarte ``KARTE`` emuliert; zur Auswahl stehen: ``sb16``, ``es1370`` und ``all``|| || ``-smp X`` || es werden X CPU in der virtuellen Maschine genutzt, die Anzahl der virtuellen CPUs kann höher sein als die der realen des Wirts || || ``-vnc :X ``||Die Ausgabe des Bildschirms erfolgt per [:VNC:] auf Display ``X`` und nicht auf den normalen Bildschirm des Wirts, Details siehe auch [#QEMU-per-VNC hier]|| || ``-snapshot`` || Dies bewirkt, dass Änderungen nicht in das Festplattenimage geschrieben, sondern in einer temporären Datei gespeichert werden. Erst mit den Tasten [[Vorlage(Tasten, Strg+Alt+s)]] oder dem Kommando '''commit''' in der QEMU-Konsole werden die Änderungen übernommen|| || ``-k XX`` || setzt das Tastaturlayout auf den angegebenen Wert ``XX`` z.B. ``-k de`` für deutsch, ``-k en`` für englisch, etc... (Hilfreich bei Problemen mit der Eingabe und Sonderzeichen in Verbindung mit VNC) || || ``-hostfwd=[tcp|udp]:[Hostadresse]:Hostport-[Gastadresse]:Gastport`` || Leitet einen Port des Gasts auf einen Port des Hosts weiter. D.h. ``-hostfwd=::8008::80`` macht einen Apache-Server (bei Standardkonfiguration) des Gastsystems unter ``http://localhost:8008`` auf dem Wirt sichtbar. Oder ``-hostfwd=::8022::22`` erlaubt ssh-Zugriff (bei Standardkonfiguration) auf das Gastsystem vom Wirt via ``ssh -p 8022 localhost``|| || ``-no-quit`` || Deaktiviert die Fenster-Schließen-Option. Verhindert z.B., dass beim Drücken von [[Vorlage(Tasten, Alt+F4)]] das Fenster geschlossen und die VM beendet wird, wenn die Kombination eigentlich für den Gast gedacht war (z.B. dort Fenster schließen oder zur 4. [:Terminal#Virtuelle-Konsole:Virtuellen Konsole] wechseln). QEMU kann weiterhin mit `quit` im [#QEMU-Monitor QEMU-Monitor] beendet werden|| || ``-cpu X`` || Legt den Typ der CPU fest, mittels ``-cpu host`` kann die Host-CPU definiert werden (funktioniert nur in Verbindung mit aktiviertem KVM: ``-enable-kvm``) || Dies ist nur ein (sehr) kleiner Ausschnitt der Optionen. Besonders im Bereich der Netzwerk-Optionen gibt es sehr viele Möglichkeiten. Eine vollständige Übersicht findet man in den [:man:Manpages] oder im [http://wiki.qemu.org/QEMU-doc.html QEMU-Wiki] {en}. == Portforwarding (z.B. SSH) == Wie unter den [#Startoptionen Startoptionen] aufgeführt, kann man Dienste vom Gast auf dem Host erreichen. {{{#!vorlage Befehl qemu [weitere Optionen] -hostfwd=::2222-10.0.2.20:22 }}} In diesem Beispiel wird der Port 22 des Gastes auf den Port 2222 des Hosts weitergeleitet, um den Gast vom Host mit {{{#!vorlage Befehl ssh -p 2222 localhost }}} erreichen zu können. Damit dies richtig funktioniert, muss die Option ggf. in den richtigen Netzwerkkontext eingebettet werden - standardmäßig ist das der sehr einfach zu benutzende, aber vergleichsweise sehr langsame und unflexible Modus `user network` (Benutzer-Netzwerk): {{{#!vorlage Befehl qemu [weitere Optionen] -net nic,macaddr=52:54:00:12:34:56 -net user,hostfwd=::2222-10.0.2.20:22 }}} Die MAC-Adresse ist die standardmäßig voreingestellte mit `55` am Ende, um Eins erhöht, und kann weiter verändert bzw. die `56` weiter erhöht werden. Jede virtuelle Maschine im Netzwerk muss seine eigene, unverwechselbare MAC haben. == Andere Architekturen emulieren == QEMU ist nicht auf die Virtualisierung / Emulation von x86 Prozessoren beschränkt, es können auch eine Vielzahl von anderen Architekturen emuliert werden. Welche dies aktuell sind kann man [https://www.qemu.org/docs/master/system/targets.html hier] {en} nachschauen. Die allgemeine Syntax ist {{{#!vorlage Befehl qemu-system-ARCHITEKTUR [OPTIONEN] }}} wobei ``ARCHITEKTUR`` entsprechend ersetzt werden muss. == Reine Prozessemulation == QEMU beherrscht auch die "reine" Prozessemulation, auch "User-Space-Emulation" genannt. D.h. dass anstatt eines kompletten Systems wird "nur" ein einzelnes Programm ("Binary") im Emulations-Modus ausgeführt. Die Prozess-Emulation für ein 32-bit i386 System wird z.B. mit folgendem Befehl aufgerufen: {{{#!vorlage Befehl qemu-i386 PROGRAMMNAME }}} Die Emulation funktioniert natürlich nur, wenn das Programm keine weiteren Bibliotheken dynamisch nachlädt. Außer der i386-Emulation beherrscht QEMU u.a. auch die Prozessemulation für SPARC, PPC, ARM und einige mehr. Detaillierte Informationen findet man in der [https://www.qemu.org/docs/master/user/index.html QEMU-Dokumenation] {en}. == QEMU-Festplattenimages unter Linux einbinden == QEMU bietet die Möglichkeit, die Images über das Netzwerk anzubieten. Das lässt sich aber auch gut verwenden, um sie auf dem eigenen Rechner einzubinden. Aber Achtung: Das Image darf dabei nicht von QEMU oder einem anderen Programm in Benutzung sein. Zuerst muss NBD geladen werden: {{{#!vorlage Befehl sudo modprobe nbd }}} Sollte man sehr viele Partitionen im Image haben kann es nötig sein zusätzlich die Anzahl der Partitionen zu erhöhen: {{{#!vorlage Befehl sudo modprobe nbd max_part=63 }}} Jetzt wird das Image in eine Art Loopdevice gemapped. '''pfad/zu/qemu.img''' muss man natürlich entsprechend anpassen und sollte '''/dev/nbd0''' schon vergeben sein kann man auch diese Zahl anpassen. {{{#!vorlage Befehl sudo qemu-nbd --connect=/dev/nbd0 /kompletter/pfad/zu/qemu.img }}} Mit folgendem Befehl kann man sich die Partitionen anzeigen lassen: {{{#!vorlage Befehl sudo fdisk -l /dev/nbd0 }}} Und so mountet man das Image: {{{#!vorlage Befehl sudo mount /dev/nbd0p1 /mnt }}} Wenn man fertig ist sollte man das Image wieder freigeben. Zahlen gegebenenfalls anpassen. {{{#!vorlage Befehl sudo umount /dev/nbd0p1 sudo qemu-nbd -d /dev/nbd0 }}} == USB Geräte durchreichen == QEMU ist in der Lage USB Geräte des Wirts zum Gast durchzureichen. Damit USB Unterstützung grundsätzlich funktionieren kann, muss die Startoption ``-usb`` angegeben werden. Es gibt zahlreiche Möglichkeiten ein USB Gerät an das Gastsystem durchzureichen. Dabei sind die folgenden zwei Methoden besonders praktikabel: 1. Angabe von "Vendor-" und "Product-ID" des betreffenden USB Geräts 1. Angabe von USB-Bus und Port des Wirts, an dem man beabsichtigt das USB Gerät anzuschließen === 1. Methode === Die "Vendor-" und "Product-ID" mit {{{#!vorlage Befehl lsusb }}} ermitteln. Die Ausgabe enthält z.B eine Zeile wie folgt: {{{ Bus 002 Device 026: ID 090c:1000 Silicon Motion, Inc. - Taiwan (formerly Feiya Technology Corp.) 64MB QDI U2 DISK }}} Dieser USB-Stick hat die "Vendor-ID" ``090c`` und "Product-ID" ``1000``. Die Syntax für die entsprechende Startoption lautet: {{{#!vorlage Befehl qemu [OPTIONEN] -usb -device usb-host,bus=usb-bus.0,vendorid=0x,productid=0x }}} Im QEMU-Monitor macht man das mit: {{{#!vorlage Befehl device_add usb-host,vendorid=0x:productid=0x }}} Wenn alles gut gegangen ist, sollte sich das USB Gerät nun im Gast anmelden. Leider gibt es aber auch exotischere USB Geräte die sich so nicht zur Mitarbeit bewegen lassen. Unter Umständen wird die "Vendor-" und "Product-ID" nicht korrekt an das Gastsystem weitergereicht. In einem Windows XP Gast z.B. macht sich dieses Problem als "Unbekanntes Gerät" bemerkbar. === 2. Methode === Verweigert ein USB Gerät die Mitarbeit oder möchte man prinzipiell einen ausgewählten USB-Port an einen Gast weiterreichen, dann kann man folgende Methode ausprobieren. Nach dem Anstecken kann mit: {{{#!vorlage Befehl dmesg | tail -n 20 }}} der USB-Bus und Port des betreffenden Geräts ermittelt werden. Der interessante Teil der Ausgabe sieht dann z.B. so aus: {{{ [29383.460263] usb 6-1: new full-speed USB device number 14 using uhci_hcd [29383.622414] usb 6-1: New USB device found, idVendor=10c4, idProduct=8044 [29383.622427] usb 6-1: New USB device strings: Mfr=1, Product=2, SerialNumber=3 [29383.622436] usb 6-1: Product: USB Debug Adapter [29383.622444] usb 6-1: Manufacturer: Silicon Laboratories [29383.622450] usb 6-1: SerialNumber: EC30000D370 [29385.340305] usb 6-1: reset full-speed USB device number 14 using uhci_hcd [29385.688125] usb 6-1: reset full-speed USB device number 14 using uhci_hcd }}} In diesem Fall hängt das Gerät also an USB-Bus 6 Port 1. Die Syntax für die entsprechende Startoption lautet: {{{#!vorlage Befehl qemu [OPTIONEN] -usb -device usb-host,bus=usb-bus.0,hostbus=,hostport= }}} Dabei ist `bus` die soeben ermittelte USB-Bus Adresse und `port` der entsprechende USB-Port. Im QEMU-Monitor geht das so: {{{#!vorlage Befehl device_add usb-host,bus=usb-bus.0,hostbus=,hostport= }}} Weiterführende Informationen dazu findet man im [http://www.kraxel.org/cgit/qemu/tree/docs/usb2.txt USB 2.0 Quick Start] {en} Dokument. [[Bild(Wiki/Icons/hint.png, 48, align=right)]] = Problembehebung = [[Anker(shm_mount)]] == Virtuelle Maschine bekommt nicht genug RAM == Startet man QEMU mit der Option `-m XXX`, aber die virtuelle Maschine bekommt trotzdem nicht genug Speicher, ist vielleicht das virtuelle Dateisystem unter '''/dev/shm''' bzw. ab [:Oneiric:Ubuntu 11.10] '''/run/shm''' zu klein. Dann kann man in der [:fstab:/etc/fstab] folgende Ergänzung vornehmen (Verzeichnis ggfs. anpassen) [4]: {{{#!code sh # /dev/shm Vergrößern für QEMU none /dev/shm tmpfs defaults,size=528M }}} Hier steht nun "size=528M" für 528 MiB. Dieser Wert muss ggf. angepasst werden und sollte etwas größer sein, als der tatsächlich für den Gast benötigte RAM, da unter '''/dev/shm''' noch weitere Daten abgelegt werden. Ohne neu booten zu müssen, kann man das tmpfs gleich neu einbinden [3]: {{{#!vorlage Befehl sudo mount -o remount /dev/shm }}} Wenn man nun QEMU startet, kann man mit dem Befehl {{{#!vorlage Befehl df | egrep 'shm|File' }}} überprüfen, wie viel des virtuellen RAM genutzt wird. {{{#!vorlage Hinweis Man sollte darauf achten, dass man QEMU nicht mehr RAM zuweist als dem Wirt-Rechner, da QEMU dann instabil laufen könnte. Außerdem sollte man dem Wirt-System genügend RAM lassen, dass es noch flüssig läuft. Die genauen Systemanforderungen kann man den Release Notes von Ubuntu und seinen Derivaten entnehmen. Die Untergrenze für RAM liegt bei 128-512 MiB. }}} == ping funktioniert auf dem Gast nach Installation nicht== QEMU startet einen Gast standardmäßig im Modus [https://en.wikibooks.org/wiki/QEMU/Networking#User_mode_networking `user network`], welches keinen `ping` unterstützt. Eine Alternative zu `user network` mit `TUN/TAP interface` wird im Abschnitt [:QEMU#Netzwerk:Netzwerk] erklärt. Alternativ zu `ping` kann man andere Tools zu verwenden, um auf dem Gast nach der Installation zu prüfen, ob Internetverbindung von Gast mit dem weltweiten Internet hergestellt wurde. Ein alternativer Befehl wäre: {{{#!vorlage Befehl wget -O - fsf.org 2>&1|grep free|wc }}} wobei die Ausgabe dann so oder ähnlich aussehen sollte: {{{ 27 269 2980 }}} == Die VM läuft im Grafikmodus sehr langsam == Die meisten Desktopumgebungen verwenden die 3D-Beschleunigung der Grafikarte für ihre Effekte. Diese kann nicht in allen Konfigurationen von QEMU im Gast genutzt werden. Eine Alternative ist LXQt mit dem Paket `lubuntu-desktop` ([:Lubuntu:]). Eine 2D-Beschleunigung wird mit der virtuellen Grafikkarte qxl unterstützt. Soll im Gast 3D-Beschleunigung verwendet werden, kann als Grafikkarte '''-device virtio-vga-gl''' und als Display '''-display sdl,gl=on''' eingestellt werden. == Virtuelle Festplatte ist voll == Das Festplattenimage kann in zwei Schritten vergrößert werden. {{{#!vorlage Warnung Vor dem Ändern der virtuellen Festplatte das Backup nicht vergessen }}} Zunächst wird die Imagedatei, die auf der realen Festplatte des Hosts liegt, vergrößert, z.B. um 10 GB: {{{#!vorlage Befehl qemu-img resize Pfad/zum/Image.img +10G }}} Nun muss noch die Partition der virtuellen Festplatte vergrößert werden. Die geschieht wie die Imagevergrößerung einer echten Festplatte. Hierzu lädt man sich am Besten ein Iso von gparted [https://gparted.org/download.php herunter] {en}. Anschließend startet man die virtuelle Maschine vom Image aus, so wie man einen echten Rechner von einer CD aus starten würde: {{{#!vorlage Befehl qemu -hda Pfad/zum/Image.img -boot d -cdrom Pfad/zum/iso/gparted-live-1.4.0-6-amd64.iso -m 2048 }}} Nun wählt man zuerst die Sprache und Tastaturlayout aus und wählt dann die Option, den Xserver zu starten. Jetzt lässt sich die Größe der Partition bequem grafisch an die neue virtuelle Festplattengröße anpassen. Zum Starten muss lediglich das Icon von gparted angeklickt werden. = Links = * [https://www.linuxforen.de/forums/showthread.php?t=141201 Anleitung auf Linuxforen.de] {de} - Eine umfangreiche Einführung * [https://www.qemu.org/documentation/ QEMU User-Dokumentation] {en} - Die offizielle Dokumentation * [http://bochs.sourceforge.net/ Bochs] {en} - Ein weiterer freier Plattform-Emulator * [https://www.reddit.com/r/archlinux/comments/1fg3y9/guide_to_running_windows_7_in_qemu/ Guide to running Windows 7 in QEMU] {en} - Anleitung aus 2013 für Arch Linux. Leicht verständlich und knapp, funktioniert genauso gut unter Ubuntu * [http://wiki.openmoko.org/wiki/OpenMoko_under_QEMU Anleitung im OpenMoko-Wiki für QEMU] {en} - Das Betriebssystem [wikipedia:OpenMoko:] unter QEMU * [ubuntu_doc:community/WindowsXPUnderQemuHowTo:Windows XP under QEMU HowTo] {en} - Dokumentation von Ubuntu.com * [https://www.linuxtechi.com/install-configure-kvm-ubuntu-18-04-server/] {en} - HowTo Netzwerkbrücke mit Netplan einrichten # tag: Emulation und Virtualisierung, KVM