# FAQ Tips > Hier Suchen und Finden, Links, Tutorials >  Qemu / KVM

## stefan.becker

*Inhalt:*

1) Was ist Qemu?

2) Installation

3) Der erste Test, fertige OS-Images

4) Installation von Windows 98 als Gastbetriebssystem

5) Tipps&Tricks im Umgang mit Gastbetriebssystemen wie z. B. Windows (98)

6) Und so sieht es aus

7) Aktuelle Probleme und Lösungen

8) Drucken und Dateizugriff per Samba, Scannen über Netzwerk, Netcapi

9) Anlegen und Verwaltung von Disk-Images

10) GUIs für QEMU

11) Qemu unter Windows

12) Qemu und VNC

13) KVM - Kernel based Virtual Machine


*Hinweis zur Qemu Version:*

An verschiedenen Stellen im Howto werden Versions-Nummern genannt. Ist die genannte Version neuer als die aktuelle, ist damit die GIT-Version gemeint. Zur Installation der GIT-Version siehe 2.3).


*Änderungen:*

20.06.04: erstellt
21.06.04: Win98 als Gast
22.06.04: Internetzugang, Screenshot
23.06.04: Drucken (5)
24.06.04: Neues Kapitel 7), WinSCP für Dateiaustausch (5)
05.07.04: lomount zum Mounten (5, Dateiaustausch)
11.07.04: Aktualisierung Qemu 0.60, CPU-Auslastung verringern unter Win9x (5)
13.07.04: Downloadlink FreeOSZoo (fertige Images) (3)
18.07.04: Windows NT 4 installieren (7)
19.07.04: Hinweis auf 1024 Hz-Timer, Qemu-Konsole (5), Bochs Images (3)
11.09.04: Samba (Kapitel 8)
19.09.04: Kapitel 2 ergänzt (Windows Version, Hardware, Netzwerkfähigkeiten)
15.11.04: Aktualisierung auf Version 0.61.
18.11.04: Soundinstallation erweitert, Speichern/laden der virtuellen Maschine
27.11.04: CVS-Installation (2.3)
12.12.04: Disk-Images (9) neu
12.02.05: Hinweis auf Arbeitsgruppe/Samba, KQEMU
04.03.05: 5) Windows Gast Tuning Tipps
10.03.05: 10) weitere Tipps, 5) mpcb Zwischenablage, 7) Win2K Disk Full Problem
12.03.05: serielle Schnittstelle mit slsnif (5), KQEMU-Installation (11)
22.03.05: GUIs (12)
29.04.05: Drucken per Samba ergänzt/korrigiert (8)
24.05.05: Scannen (8.2)
28.05.05: Samba Server aus Qemu benutzen (8.1.2)
30.05.05: Drucker per IPP (8.1.3)
26.06.05: QVM86 (11.2)
13.08.05: Links aktualisiert
14.08.05: Windows Update CDs installieren (4.5)
05.11.05: USB, Alsa, ES1370-Sound, Hinweis auf VMWARE Player
09.11.05: USB_DEL Kommando, serielle Schnittstelle
10.11.05: Parallelport
04.12.05: Parameter für Usernetzwerk angepasst (-net nic -net user), CVS-Hinweis
18.12.05: KQEMU / UDEV
20.12.05: Qemu 0.80
31.12.05: FAT virtuell
06.01.06: Qemu für X64-Emulation
07.01.06: Beispiel TUN/TAP-Konfiguration (8.3)
08.01.06: Zwischenablage per Synergy (8.4), APM bei WIN XP&2K
10.01.06: fließender Mauswechsel Host/Gast per Synergy (8.4.6)
29.01.06: Links aktualisiert, SaneTwain Hinweise
06.02.06: Qemu unter Windows (13)
26.03.06: KQEMU 1.30
29.04.06: Links aktualisiert, Kapitel 1 überarbeitet
01.05.06: Qemu per VNC (14), mpcb entfernt, ShareClip (8.5)
03.05.06: VNC korrigiert, USB-HID-Maus übergangslos (5)
05.08.06: Windows Update/Win2K Hack (7)
09.09.06: Netcapi-Link, Rechte für TUN-Interface
07.10.06: Links aktualisiert, QVM86 entfernt (Projekt tot)
05.11.06: Qemu / xgl&compiz (7)
24.11.06: Qemu Guest Tools (8.4.2)
13.12.06: TUN/TAP ab Kernel 2.6.18
06.01.07: Links aktualisiert, Qemulator (GUI)
07.01.07: QtEmu-Link
06.02.07: KQEMU / GPL
12.02.07: Problem Qemu übersetzen (0.9/Suse 10.2), TUN/TAP ergänzt
18.02.07: KVM
22.05.07: Seamless Desktop
30.09.07: NTFS Image vergrößern (9.3)
03.02.08: aktualisiert, Links kontrolliert, VMWARE-VGA, Intel e1000
04.04.08: Umstellung CVS=>SVN
28.04.08: Übergangslose Maus / Linux-Gast / evtouch-Treiber
19.03.09: Alle Links aktualisiert, ac97 Sound, gcc3 Hinweis entfernt,VirtIO, Syntax e1000 korrigiert
27.03.09: Beispiel-Bridge-Konfiguration
29.03.09: Xenner-Link, hpet aus, OpenQRM-Link
26.04.09: SVN abgelöst durch GIT
21.11.09: Komplett überarbeitet, aktualisiert auf Stand Qemu 0.11.x (kvm, smb etc) (kqemu gestrichen)
03.12.09: Links aktualisiert (qemu.org)
03.02.10: Links aktualisiert (qemu wiki)

----------


## stefan.becker

*Full system emulation*

Qemu ist wie VMWARE oder Bochs ein PC-Emulator, der das parallele Betreiben anderer Betriebssysteme ohne Neustart des PCs erlaubt. Im Vergleich zu Bochs ist die Einrichtung relativ einfach als auch die Performance akzeptabel.

Der große Unterschied zu anderen Emulatoren: Qemu läuft auch auf anderen Prozessoren als x86 und kann andere Prozessoren emulieren als einen Pentium.

Beispiele:
- Pentium Host mit Linux, x86 emulieren, Windows als Gast
- Pentium Host mit Windows, x86 emulieren, Linux als Gast
- PowerPC Host mit McOS, Sparc emulieren, Solaris als Gast

Alle möglichen Kombinationen sind aus den unten angegebenen Links (Prozessoren, Betriebssysteme) zu entnehmen.

Die Emulation der CPU kostet natürlich Rechenleistung, so dass der Gast merklich langsamer läuft als auf gleichwertiger, echter Hardware.

VMWARE wird auch als *Virtualisierer* bezeichnet. Gemeint ist damit, dass der Prozessor nicht emuliert wird, sondern die Befehle des Gast-PCs direkt auf dem Hostprozessor ausgeführt werden. Dadurch läuft das Betriebssystem im virtuellen PC fast so schnell wie auf der echten Hardware.

Zunächst wurde im Rahmen des Qemu Projektes das Beschleunigermodul *KQEMU* entwickelt, wodurch auch Qemu in den Genuss von Virtualisierung kam. Natürlich mit den dadurch bedingten Einschränkungen: 

- Host muss einen Prozessor x86 bzw. x86-64 haben
- Der Gast nutzt natürlich 1:1 den gleichen Prozessor

*KVM* (siehe Kapitel 13) ist ein Qemu-Ableger. Er nutzt die virtuelle Maschine von Qemu zur Emulation und bietet ein Kernelmodul, dass die Virtualisierungstechniken moderner Prozessoren nutzt. Alles hier für Qemu genannte gilt 1:1 für KVM.

Seit neustem (Stand 11.09) scheint KQEMU tot zu sein. Stattdessen nutzt auch die Standard-Qemu-Version inzwischen KVM. Da KVM inzwischen im Linux Kernel standardmäßig enthalten ist, muss auch nichts extra installiert werden.


*User Mode Emulation*

Außerdem kann mit Qemu auf einem Linux Host eine User Mode Emulation gestartet werden. Damit kann ein zweiter Linux-Kernel parallel starten, darunter z. B eine speziell angepasste WINE Version. Das gibt Anwendern von z. B. Power-PC-Rechnern die Möglichkeit, Windows Programmme zu starten.


*Emulierte Hardware*

Unabhängig von der echten Hardware emuliert Qemu daraus folgende Standardhardware:

- IDE-Controller mit bis zu 4 IDE Festplatten (Diskimages)
- Diskettenlaufwerk
- CDROM
- Soundblaster 16 Soundkarte (aternativ ES1370, ac97)
- Cirrus Logic Grafikkarte 5446 PCI (alternativ VESA-VGA, VMWARE-VGA)
- Standard PS2 Rad-Maus
- Realtek RTL 8029(AS) PCI Ethernet, alternativ Intel E 1000
- serielle Schnittstelle (COM 1)
- Parallelport (LPT 1)
- USB-UHCI (Intel SB82371)
- Gameport Joystick


*Netzwerkfähigkeiten*

Standardmäßig bietet Qemu ein NAT-Netzwerk ähnlich zu VMWARE/VirtualBox. Zugriff auf Internet, Ressourcen des Hosts und Zugriff auf Hostdateien über einen integrierten Sambaserver ist damit problemlos möglich.

Über Standard-Linux-TUN/TAP-Netzwerkschnittstellen lässt sich auch ein Bridged-Netzwerk einrichten. Dies erfordert jedoch einige manuelle Konfiguration.


*Welche Windows Version als Gast?*

Siehe auch Kapitel 13, Beschleunigung durch KVM.

Ohne die Beschleunigung sind Windows 98 und NT 4.0 erste Wahl, neuere Windows Versionen sind dann eher ungeeignet.


*Weitere Hilfe:*

Homepage: http://wiki.qemu.org/Main_Page

Qemu läuft auf folgenden Host-Betriebssystemen: Linux, Windows, MacOS, *BSD 

Folgende Betriebssysteme können von Qemu ausgeführt werden: Linux, Windows, verschiedene Unix Derivate, Solaris (http://www.claunia.com/qemu/)

Wie Bochs läuft es auch auf anderen Prozessoren als auf X86-kompatiblen.

Außerdem kann Qemu auch andere Prozessoren als X86 emulieren, siehe: http://wiki.qemu.org/download/qemu-doc.html (Kapitel "Features")

Deutsches Handbuch: http://qemu-buch.de/

Qemu Dokumentation: http://wiki.qemu.org/Manual

Entwickler-Mailingliste: http://mail.freesoftware.fsf.org/mai...nfo/qemu-devel

Anwender-Forum: http://qemu-forum.ipi.fi/

GIT-Download (Entwicklungs-Version): http://savannah.nongnu.org/git/?group=qemu


*Alternativen zu Qemu:*

- *VirtualBox*:

http://www.linuxforen.de/forums/showthread.php?t=236444

VirtualBox ist für Privatanwender kostenfrei. Außerdem gibt es eine etwas eingeschränkte Open Source Variante.

- *VMWARE*: http://www.linuxforen.de/forums/show...threadid=47553

Mit VMWARE Player und VMWARE Server stehen kostenlose Varianten zur Verfügung.

- *WINE*: http://www.linuxforen.de/forums/show...threadid=48347

Windows Programme direkt ausführen (API-Emulation).

----------


## stefan.becker

*2.1) Standard-Pakete*

Inzwischen gehört Qemu zum Standardumfang jeder Distribution. Daher erstmal im Paketmanager nachsehen, ob Qemu vorhanden ist.


*2.2) selbst übersetzen*

Wer selbst übersetzen will, besorgt sich über http://wiki.qemu.org/Download das Paket "qemu-x.y.tar.gz" (xyz=aktuelle Version).

Das Auspacken&Übersetzen erfolgt nach dem Standard:



```
tar zxvf qemu*tar.gz (oder "tar jxvf qemu*bz2", wenn mit bzip2 gepackt)
cd qemu*
./configure
make
make install
```

Wer nur auf einem X86-Linux z. B. Windows starten möchte, braucht nur die reine i386-Emulation. Das spart einiges an Abhängigkeiten und Overhead und auch häufig Fehlermeldungen beim Übersetzen und fehlenden Abhängigkeiten der anderen Emulationen:



```
./configure --target-list=i386-softmmu
```

Qemu für X64-Linux:



```
./configure --target-list=x86_64-softmmu
```

Sollten Probleme beim Übersetzen auftauchen, sollten man zuerst mal die Abhängigkeiten überprüfen. Folgende Pakete werden auf jeden Fall gebraucht:

- SDL
- SDL-devel
- tetex

Ansonsten sollte man zuerst mal einen Blick in die beiliegende Datei "README" werfen und mal die Mailingliste befragen.

Weitere Parameter:
- "--prefix=/usr/local...": Basisverzeichnis für Installation
- "--enable-kvm": Übersetzen mit KVM Support für Virtualisierung
- "--audio-drv-list=alsa": Audioausgabe über ALSA (Standard OSS)


*2.3) GIT-Entwicklungsversion*

Manchmal ist die Installation der Qemu-GIT-Version nötig aufgrund eines aktuell bereits gelösten Problems.

Als Voraussetzung muss das Paket "git-core" installiert sein (Name bei Suse, kann woanders abweichen).

Download GIT-Version:


```
cd /usr/src
git clone git://git.savannah.nongnu.org/qemu.git
cd /usr/src/qemu
```

Anschließend übersetzen&installieren wie oben unter 2.1)

Aktualisieren:


```
cd /usr/src/qemu
git pull
```

Qemu GIT Homepage: http://savannah.nongnu.org/git/?group=qemu

----------


## stefan.becker

Auf der Homepage gibt es Test-Images, z. B. eine kleine Linux-Distribution (siehe "QEMU disk images").

Die Datei "linux-test-xxx.tar.gz" ziehen, entpacken mit "tar zxvf linux-test*".

Nun mit "qemu -hda linux.img" den ersten Test versuchen (X64: "qemu-system-x86_64 -hda linux.img").

Weitere fertige Images gibt es hier:


http://www.oszoo.org

Erhältlich sind Reactos (freier Windows Klon), FreeDOS und diverse Linuxe/Unixe. Damit hat man genug Stoff zum Probieren.

Auch mit/für Bochs erstellte Images sollten gehen, getestet habe ich das mit Hurd. Hier gibt es fertige Bochs Images:

http://bochs.sourceforge.net/diskimages.html


Screenshot Qemu/Linux-Konsole:

----------


## stefan.becker

Im folgenden wird die Installation von Windows 98 als Gast beschrieben. Was man schnell merkt: Im Unterschied zu Bochs ist die Konfiguration sehr einfach. Die wesentlichen Einstellungen können an der Kommandozeile übergeben werden. Eine Konfigurationsdatei ist nicht nötig.

Vorbereitung / Zutaten:

- Qemu installiert und läuft (Test siehe 3)
- Windows 98 CD 
- Bootdiskette
- Alternativ statt Bootdiskette eine bootfähige Win98 CD

Falls die Bootdiskette fehlt: http://www.bootdisk.com/, http://www.boot-land.net

Bitte das Copyright achten! Man muss natürlich im Besitz einer gültigen Windows 98 Lizenz sein. Falls nicht vorhanden, lässt sich hier preiswert eine Lizenz erstehen: http://www.ebay.de/.

*Hinweis X64-Linux: Der Befehl "qemu" wird ersetzt durch:*



```
qemu-system-x86_64 ...
```


*QEMU Optionen bei Problemen ein/ausschalten*

Sollte es bei der Installation Probleme geben, kann man einige Optionen abschalten:

ACPI: "*-no-acpi*" (http://en.wikipedia.org/wiki/Acpi)
HPET: "*-no-hpet*" (http://en.wikipedia.org/wiki/HPET)
Bsp.:


```
qemu ... -no-acpi -no-hpet
```

ACPI sollte man nur zuschalten, wenn es Voraussetzung für den Betrieb ist. Vista lässt sich z. B. nur mit ACPI installieren.

Weitere Optionen:
"-win2k-hack": Verhindert Fehlermeldung "disk full" bei Windows 2000 Installation.


*4.1) Virtuelle Festplatte / Diskimage*

Das Windows 98 soll auf eine virtuelle Festplatte installiert werden.

Der folgende Befehl legt die virtuelle Platte "win98.img" mit einer Größe von 1000 MB an:



```
qemu-img create -f raw win98.img 1000M
```

Das Konzept der virtuellen Platte / Diskimage entspricht im wesentlichen der Vorgehensweise bei VMWARE und Bochs. Es ist eine große Containerdatei, die wie eine Festplatte angesprochen werden kann. Mehr zu diesem Thema aber im Kapitel 9).


*4.2) virtuelle Platte einrichten, mit Win98 Bootdiskette starten*

Zunächst muss mit einer Win98 Bootdiskette der virtuelle PC gestartet werden, um die virtuelle Festplatte zu partitionieren. Dazu eine Win98 Bootdiskette einlegen und folgenden Befehl zum Start eingeben.



```
qemu -fda /dev/fd0 -hda win98.img -boot a -no-acpi
```

Nach Booten mit Windows-fdisk eine primäre DOS-Partition auf der virtuellen Platte anlegen, nochmals neu starten und dann mit "format c:" die virtuelle Platte formatieren.

Keine Angst, die echte Festplatte bleibt unverändert. Alle Aktionen spielen sich in der unter 4.1) erzeugten Datei ab.

Man kann übrigens auch ein Diskettenimage nehmen. Das wird erstellt über:



```
dd if=/dev/fd0 of=floppy.img
```

Im obigen Befehl dann einfach "/dev/fd0" durch "floppy.img" ersetzen.


*4.3) Win98 Installation von CD starten*

Wie oben Bootdiskette einlegen, CD einlegen und folgenden Befehl eingeben:



```
qemu -fda /dev/fd0 -hda win98.img -boot a -cdrom /dev/sr0 -no-acpi
```

"/dev/sr0" muss an den eigenen PC angepasst werden, eventuell kann auch "/dev/hdc" oder "/dev/cdrom" korrekt sein.

Zur Installation selbst gibt es nichts weiteres zu sagen, sie entspricht 1:1 der Installation von Windows auf einem "echten" PC.

Wer keine Bootdiskette hat, kann über die Boot-CD installieren mit:



```
qemu -hda win98.img -cdrom /dev/sr0 -boot d -no-acpi
```


*4.4) (Erster) Start nach der Installation*

"-boot a" und "-fda ..." sowie "-cdrom ..." können jetzt entfallen, zum Starten reicht also:



```
qemu -hda win98.img -no-acpi
```

Eventuell benötigte Laufwerke können über den Qemu-Monitor (siehe 5) später bei Bedarf eingebunden werden, siehe Tipp unten.


*4.5) Installation einer Update Version*

Viele Windows CDs sind Updateversionen, die im Laufe der Installation nach der Vorversion fragen, um die Lizenz zu überprüfen. Das Vorhandensein der Lizenz ist in diesem sowohl physikalisch als auch lizenztechnisch Voraussetzung. Hier gibt es 2 Methoden:

*Vorversion installieren*

Die einfachste Variante. Z. B. für Win98:

- zuvor Win95 installieren
- Win95 starten
- 98 CD einlegen und von Win95 aus das Update ausführen

Die Vorversion muss nicht komplett eingerichtet werden (Hardware etc), es geht ja nur drum, dass beim Update nicht nach der Lizenz gefragt wird.

*Datenträgertausch während der Installation*

Auch wieder am Beispiel Win98:

- Win98 Installation starten und ausführen bis zum Punkt der Lizenzabfrage, diese noch nicht starten
- Im Qemu Fenster über [Strg]-[2] zum Qemu-Monitor wechseln (siehe 5)
- Mit dem Kommando "eject ide1-cd0" die 98 CD freigeben, auswerfen
- 95 CD einelegen und mit dem Kommando "change ide1-cd0 /dev/sr0" einbinden
- Mit [Strg]-[1] zur Win-Installation wechseln
- Lizenzprüfung starten und warten, bis abgeschlossen
- Im Qemu Fenster über [Strg]-[2] zum Qemu-Monitor wechseln
- Mit dem Kommando "eject ide1-cd0" die 95 CD freigeben, auswerfen
- 98 CD einelegen und mit dem Kommando "change ide1-cd0 /dev/sr0" einbinden
- Mit [Strg]-[1] zur Win-Installation wechseln und diese zu Ende führen

Hier jeweils die Annahme, dass "/dev/sr0" das CD-Laufwerk ist. Hier bei Abweichungen das richtige Device eintragen. Falls diese Methode nicht funktioniert, kann man statt der CD auch Images vorher anlegen per dd-Befehl und diese als CD Laufwerk einbinden.

Hinweis: Das Device für das Qemu-CD Laufwerk (hier "ide1-cd0") kann man durch "info block" herausbekommen.

----------


## stefan.becker

*Qemu-Monitor*

Im Qemu-Monitor kann man Befehle zur Verwaltung der virtuellen Maschine eingeben. Bsp. dazu weiter unten.

Bis Qemu 0.60 ist der Qemu-Monitor die Befehlszeile, von der aus man Qemu gestartet hat.

Ab Version 0.61 ist der Monitor standardmäßig im Qemu-Fenster untergebracht:

[Strg]-[Alt]-[2]: schaltet vom Gast um auf den Qemu-Monitor
[Strg]-[Alt]-[1]: schaltet vom Qemu-Monitor zurück zum Gast

Die Tastenkombination muss also im Windows Gast eingegeben werden. 

Der Befehl "info" zeigt eine Übersicht über alle Kommandos des Qemu-Monitors. Beispiele sind weiter unten zu finden, zum Beispiel zum Einbinden und Auswerfen von Datenträgern.

Über den Startparameter "qemu ... -monitor device" kann man festlegen, wo der Monitor erscheinen soll. Siehe dazu auch "man qemu". Mit "-monitor stdio" kann man z. B. bei Qemu mit Grafikfenster den Monitor auf die Konsole legen, von der aus man Qemu gestartet hat.

Weitere Tastenkombinationen:

[Strg]-[Alt]: Gibt die Maus wieder frei (Maus im Gast "gefangen", Kontrolle zurück an Host)
[Strg]-[Alt]-[F]: Umschalten Qemu Fullscreen <=> Fenster


*Support für VirtIO*

Ab Qemu 0.10.0 lassen sich, sofern das Paket "libvirt" installiert ist, VirtIO Interfaces nutzen.

Siehe auch http://wiki.qemu.org/download/qemu-doc.html, Kapitel "Invocation"

Bsp.: "qemu ... -drive ..."

Der Vorteil: Die Zugriffe laufen paravirtualisiert und damit schneller ab.

Natürlich braucht man dafür entsprechende Treiber, die gibt es auf der KVM Homepage: http://sourceforge.net/projects/kvm/files/ (kvm-guest-drivers-windows)

Weitere Tipps: http://www.carfax.org.uk/docs/qemu-virtio


*Höhere Bildschirmauflösung*

Standard:

Es wird eine Cirrus Logic 5446 GL PCI-Grafikkarte emuliert. Der benötigte Treiber ist bei allen Windows-Versionen serienmäßig.

Damit ist eine Auflösung bis zu 1024x768 bei 32 Bit bzw. 1280x1024 bei 16 Bit möglich.

Alternative 1 "Super VGA":

Alternativ ist eine VESA-Grafik möglich, dazu starten mit:


```
qemu ... -vga std
```

So werden auch höhere Auflösungen unterstützt wie z. B. 1280x1024/1600x1200 bei 32 Bit.

XP erkennt die Vesa-Grafik automatisch. Bei anderen Windows-Versionen wird ein spezieller VESA-Treiber benötigt. Z. B. der Scitech Display Doctor oder folgender Freeware-Treiber: http://bearwindows.boot-land.net/vbe9x.htm

*Wichtig:* Im Gast muss natürllich ein entsprechender Monitortyp ausgewählt sein, z. B. Super-VGA 1280x1024, sonst klappt das ganze natürlich nicht.

Alternative 2 "VMWARE Vga":

Erforderlich sind eine Vmware-Tools-Iso-Datei (z. B. bei der Workstation oder Server dabei) und eine Qemu Version >= 0.91. Qemu wird jetzt so gestartet:


```
qemu ... -cdrom windows.iso -vga vmware
```

Normalerweise wird beim Hochfahren die Grafikkarte automatisch erkannt und der Treiber vom ISO-CDROM gefunden. Falls nicht, eventuell über Systemsteuerung/Hardware das ganze manuell ausführen.


*Übergangslose Maus => USB HID / Tablet (1)*

Ab Qemu 0.81 kann eine HID-Maus emuliert werden (unabhängig von der tatsächlichen Maus):



```
qemu ... -usb -usbdevice tablet
```

Der Gast muss natürlich USB und auch USB-HID Geräte unterstützen (ab Win98 SE).

Der große Vorteil: Die Maus kann übergangslos zwischen Host und Gastfenster wechseln, wird also nicht mehr im Gast "gefangen". Bekannt ist das bei VMWARE über die VMWARE-Tools.

Bei einem Windows Gast ist nichts weiter einzurichten.

Für einen Linux Gast ist der "evtouch"-Treiber zu installieren:

http://stz-softwaretechnik.com/~ke/t...n/evtouch.html

Danach muss man herausfinden, welches Event-Interface man nehmen muss (Kommandozeile im Gast, root):


```
cat /proc/bus/input/devices
```

Das gewünschte Interface ist "... QEMU USB TABLET". Steht dort "event3", kann man einen Eintrag in die "xorg.conf" als Ersatz für die bisherige Maus vornehmen, bei "Option Device" die zuvor bestimmte Schnittstelle eintragen:


```
Section "InputDevice"
        Identifier "Mouse1"
        Driver "evtouch"
        Option "Protocol" "usb"
        Option "Device" "/dev/input/event3"
        Option "DeviceName" "touchscreen"
        Option "SendCoreEvents"
        Option "CorePointer"
        Option "MinX" "0"
        Option "MinY" "0"
        Option "MaxX" "32767"
        Option "MaxY" "32767"
        Option "ReportingMode" "Raw"
EndSection
```

Nach einem Neustart des X-Servers sollte die übergangslose Maus einwandfrei funktionieren.


*Übergangslose Maus => VMMOUSE (2)*

Ab Qemu 0.91 ist eine VMWARE kompatible Maus (VMMOUSE) integriert.

Dazu bei einem Linuxgast die "xorg.conf" editieren:


```
Section "ServerLayout"
 Identifier "Default Layout"
 Screen 0 "Screen0" 0 0
 InputDevice "Keyboard0" "CoreKeyboard"
 InputDevice "VMMouse" "CorePointer"
EndSection

Section "InputDevice"
 Identifier "VMMouse"
 Driver "vmmouse"
 Option "Device" "/dev/input/mice"
 Option "Emulate3Buttons" "yes"
EndSection
```

Bei einigen Distributionen ist der Treiber enthalten. Ansonsten gibt es eine freie Version der VMWARE Tools unter: http://open-vm-tools.sourceforge.net/

Nach einem Neustart des X-Servers sollte die übergangslose Maus einwandfrei funktionieren.


*Mehr Speicher für virtuelle Maschine*



```
qemu ... -m 256
```

Die zusätzliche Einstellung "-m 256" weist dem virtuellen PC 256 MB Arbeitsspeicher zu. 128 MB sind die Voreinstellung.


*Internetzugang*

Ab der Version 0.60 ist ein DHCP-Modul enthalten. Der Internetzugang des Linuxhosts wird damit ohne weitere Einrichtungen in Windows verfügbar. Einfacher geht es wirklich nicht. Einfach die Hardwareerkennung starten, es wird dann eine Netzwerkkarte vom Typ "Realtec RTL 8029 PCI" erkannt. Damit kann der laufende Internetzugang des Linuxhosts einfach mitbenutzt werden.

Weitere Einstellungen (von blub aus folgendem Thread http://www.linuxforen.de/forums/show...8&postcount=14):

Client für Microsoft-Netzwerke
Realtek RTL 8029
TCP/IP Protokoll
Dann Eigenschaften von TCP-IP klicken
IP: Adresse automatisch beziehen
Gateway: 10.0.2.2 (kein Muss, geht auch ohne)
IE 6.0: Extras -> Internetoptionen -> Verbindungen -> Netzwerk -> Automatische Suche der Einstellungen.

Qemu muss dazu mit den Parametern "-net nic -net user" gestartet werden:



```
qemu ... -net nic -net user
```


*Sound (SB16)*

Zunächst muss man Qemu mit dem Parameter *-soundhw sb16* starten, weil Audio als Standard ausgeschaltet ist.

Emuliert wird eine Creative SB16/AWE32-Karte.

Typ: Soundblaster 16 oder AWE 32
E/A-Bereich: 0220-022F
IRQ: 5
DMA 1: 01
DMA 2: 05 

Falls die automatische Hardwareerkennung nicht funktioniert, einfach mal manuelles Hinzufügen probieren.

Falls Qemu von einer Konsole aus gestartet wurde, erscheinen in der Konsole einige Warnungen "sb16-...". Einfach ignorieren, es sollte dennoch gehen.

Bei Versionen vor 0.80 heisst der Parameter zur Audioaktivierung übrigens "-enable-audio".


*Sound (ES 1370)*

Ab Version 0.80 emuliert Qemu zusätzlich einen ES1370 Soundchip. 

Befehl: "qemu ... -soundhw es1370".

Für Windows ME/2K/XP ist der Treiber bereits auf der Installations-CD.

Treiber für Windows 9x: http://franklinschools.nls.k12.la.us...s/audiopci.zip

Die Soundkarte sollte unter Windows nach korrekter Installation als "ENSONIQ AudioPCI" auftauchen.

Sollte der Sound nach der Installation nicht direkt klappen, eventuell folgendes versuchen:
- Win98 starten, alle Einträge aus "Audio, Video und Gamecontroller" entfernen
- Neu starten mit "qemu ... -soundhw all"
- SB 16 manuell einrichten
- Neu starten, Treiber installieren
- Neu starten mit "qemu ... -soundhw es1370"
- In der Systemsteuerung die sb16-Einträge löschen


*Sound (AC97 / Intel Codec)*

Ab Version 0.10.0 emuliert Qemu zusätzlich einen AC97 Soundchip. 

Befehl: "qemu ... -soundhw ac97".

Für Windows 2K/XP/Vista 32 ist der Treiber bereits auf der Installations-CD.

Bei Vista 64 sollte der Realtek Treiber helfen: http://www.start64.com/index.php?opt...545&Itemid=108


*Sound-Alsatreiber*

Ab Qemu 0.80 ist auch die Soundausgabe per Alsa möglich. Zuvor ging das nur über OSS bzw. die OSS-Emulation in Alsa:

Zunächst muss Qemu mit Alsa übersetzt werden. Dazu muss natürlich das "alsa-devel"-Paket installiert sein. Anschließend:



```
./configure .... --audio-drv-list=alsa
```

Dann wie gewohnt "make" und "make install". 


*Audio-Optionen*

"qemu ... -soundhw sb16" (bzw . "es1370") => wählt den zu emulierenden Soundkartentyp
"qemu -soundhw ?" => Ausgabe aller Audio-Optionen


*USB*

Ab Qemu 0.80 gibt es einen USB-Support. Emuliert wird ein Intel SB82371 UHCI-Controller.

Zum hinzufügen von Geräten wird die Vendor-ID und die Product-ID des Gerätes gebraucht. Das bekommt man raus durch "cat /proc/bus/usb/devices". In der Ausgabe das entsprechende Gerät suchen.

Dann Qemu so starten:



```
qemu ... -usb -usbdevice host:VendorID:ProductID
```

Man kann auch zunächst nur mit "-usb" starten. Im Qemu-Monitor (Strg-Alt-2) kann man dann per "usb_add host:VendorID:ProductID" Geräte hinzufügen.

Was an externen Geräten genau geht, muss man testen. Z. B. mein Scanner "Canon LIDE 20" funktioniert tatsächlich damit. Nach wie vor ist der Kauf linuxtauglicher Hardware die bessere Lösung.

Wichtig: Es werden nur Geräte erkannt, die aktuell von Linux nicht benutzt werden. Es darf also aktuell kein Treiber geladen sein. Will man das Laden des Treibers beim EInstecken des Devices verhindern, muss die Hotplug-Blacklist bearbeitet werden (/etc/hotplug/blacklist).

Weitere USB-Kommandos im Qemu-Monitor:

- "info usbhost": zeigt am Host-USB-Controller angeschlossene Geräte
- "usb_add host:x:y": Für x den Port, für y die Gerät-Nr. eintragen, ermitteln per "info usbhost"
- "usb_del x.y": Gerät wieder freigeben, "x.y" ermitteln über "info usb" 
- "info usb": zeigt alle von Qemu genutzte USB-Geräte


*Datenaustausch Host<=> Gast*

Seit Version 0.61 kann man per SAMBA wie bei VMWARE den Datenaustausch zwischen Host und Gast vornehmen (siehe Kapitel 8). Alternativen ohne Samba:

*FAT-virtuell: Zugriff auf die virtuelle Festplatte (1)*

Ab Version 0.71 gibt einen es virtuellen FAT-Treiber in Qemu. Dadurch lassen sich Verzeichnisse des Linux-Hosts als FAT-Image in Qemu einbinden. Beispiel:



```
qemu ... -hdb fat:/tmp
```

Damit steht das Host-Verzeichnis "/tmp" als Laufwerk "d:" im Windows Gast zur Verfügung. Der Zugriff ist in Qemu lesend. 

Das Verzeichnis kann auch als Diskette freigegeben werden:



```
qemu ... -fda fat:floppy:/tmp
```

Für schreibenden Zugriff muss "-hdb fat:rw:/tmp" angegeben werden. In diesem Fall muss der User für das Verzeichnis und alle Dateien darin Schreibrechte haben. Das arbeitet aktuell noch nicht sehr stabil (Ab Version 0.80, Beta-Stadium).

Siehe auch: http://wiki.qemu.org/download/qemu-doc.html / Kapitel "Virtual FAT disk images"


*MTOOLS: Zugriff auf die virtuelle Festplatte (2)*

Über die "mtools" (Standard bei aktuellen Distributionen) kann man vom Linux-Host auf die virtuelle Festplatte zugreifen.

Folgende Zeilen müssen in die Datei "~/.mtoolsrc" eingefügt werden:



```
mtools_skip_check=1
drive c: file="/home/stefan/qemu/win98.img" partition=1
```

(Pfade entsprechend anpassen)

Danach kann z. B. mit "mdir c:" der Inhalt der virtuellen Platte angezeigt werden, mit "mcopy datei c:" kann eine Datei auf die virtuelle Platte kopiert werden.


*SSH/SCP: Zugriff auf die virtuelle Festplatte (3)*

Eine weitere Möglichkeit ist die Netzwerkfähigkeit. Über SSH/SCP kann man vom Gast aus Dateien zum Host kopieren und auch von dort lesen. 

Hierzu kann man WinSCP verwenden (Tip von blub): http://winscp.net

Das Programm kann direkt im Gast über den IE geladen und installiert werden. 

Als nächstes muss eine Windows Kommandozeile geöffnet werden, "ipconfig" eingeben. Die bei Gateway angegebene Adresse ist die Adresse zum Login. Als Username/Kennwort muss das normale Userlogin angegeben werden. 

Als nächstes öffnet sich eine Norton Commander ähnliche Oberfläche, man kann dann hin- und herkopieren wie man will.


*Image Mounten: Zugriff auf die virtuelle Festplatte (4)*

Eine weitere Möglichkeit besteht darin, vom Host aus die virtuelle Gastfestplatte zu mounten. Hierzu gibt es das Programm "lomount". Dieses ist bei vielen Distributionen im Paket "xen-tools" enthalten.

Anwendung:



```
mkdir /mnt/qemu
lomount -diskimage win98.img -partition 1 /mnt/qemu
```

Danach hängt die virtuelle Platte wie ein normales Verzeichnis im Linux-Verzeichnisbaum unter "/mnt/qemu". Mit "umount /mnt/qemu" kann die Einbindung wieder gelöst werden. Beide Befehle brauchen übrigens Root-Rechte.


*Virtuelle Festplatte als Snapshot*

Durch Start mit "qemu ... -snapshot" werden Änderungen im Dateisystem des Gastes nicht direkt auf die virtuelle Platte geschrieben, sondern erst in temporäre Dateien.

Bei normaler Beendung gehen die Änderungen verloren, drückt man hingegen [Strg]-[a]-[s], werden die Änderungen auf die virtuelle Platte geschrieben. Alternativ kann man im  Qemu-Monitor den Befehl "commit" eingeben.

Dieser Modus ist daher ideal zum Testen geeignet.


*Verwaltung von Blockdevices (CDROM, Floppy)*

Startet man Qemu über "qemu ... -cdrom /dev/sr0", muss eine CD eingelegt sein, ansonsten startet Qemu nicht. Also sollte Qemu im Normalfall ohne CD gestartet werden. Man kann das CDROM-Laufwerk jedoch nachträglich einbinden, wenn der Windows-Gast bereits läuft. Dazu gibt man im Qemu-Monitor folgendes ein:

"info block" => Überblick über eingebundene Block Devices
"change ide1-cd0 /dev/sr0" => CDROM wird eingebunden
"eject ide1-cd0" => CDROM wird wieder freigegeben

Das Device für das CD Laufwerk (hier "ide1-cd0" kann man durch "info block" herausbekommen.

Entsprechend natürlich auch die Verwaltung von Floppys etc.


*Drucken*

Über das virtuelle Netzwerk lassen sich Drucker des Hosts oder aus dem Netzwerk einbinden. Alternativ geht auch folgender Workaround ohne Netzwerk:

- Im Windows Gast einen Postscript fähigen Drucker einrichten:

Typ: Apple Laserwriter, Anschluss: FILE:

- Im Windows Gast drucken:

Es kommt eine Eingabe zum Dateinamen, z. B. "c:\druck.ps" eingeben.

- Druckdatei auf Linux Host ziehen über mtools (siehe oben) und drucken

mcopy c:\druck.ps
lpr druck.ps


*Zeit Host / Gast weicht ab*

Qemu starten mit "qemu ... -localtime", dann hat der Gast die gleiche Zeit wie der Host.


*CPU-Auslastung verringern*

WinDOSen verbrauchen auch CPU-Zeit, wenn inaktiv. Damit wird auch die Host CPU belastet, wenn man nichts im Gast macht. Dies betrifft also DOS/Win311, Win9x/ME.

Lösung: Installation eines CPU-Coolers wie DOS-Idle, ANMHLT, Rain.

Siehe auch: http://www.benchtest.com/cooler.html

Nach einem Neustart verbraucht der emulierte PC bei Nichtbenutzung keine CPU-Zeit mehr.

Alle NT basierenden Windows-Varianten (NT 4/2K/XP) haben das Problem nicht!


*Speichern / laden der virtuellen Maschine*

Seit 0.61 kann Qemu den Zustand der virtuellen Maschine speichern und beim Hochfahren einfach statt kompletten Reboot einfach ab der eingefrorenen Stelle weiterarbeiten.

Zunächst einmal Qemu inkl. Windows Gast wie gewohnt starten. Dann mit [Strg][Alt][2] zum Monitor schalten und folgenden Befehl eingeben:



```
savevm win.sav
quit
```

Der Speicherinhalt und der Prozessorzustand werden in der Datei "win.sav" gespeichert.

Zum erneuten Start folgendes eingeben:



```
qemu ... -loadvm win.sav
```

Die virtuelle Maschine läuft jetzt an der gleichen Stelle weiter wie bisher.

Soweit die Theorie, jetzt die Praxis:

Das ganze arbeitet noch nicht perfekt. Beim Hochfahren gibt es häufig einen schwarzen Mauszeiger und beim Anklicken eines Programms startet stattdessen ein Kontextmenü. Einmal umschalten in den Qemu-Monitor und zurück hilft.


*Tuning des Gastbetriebssystems*

Die normalen Tuningtipps ala PC-Welt helfen natürlich auch bei Qemu mit Windows als Gast. Auf dieser Seite finden sich viele Tipps:

http://www.windows-tweaks.info/


*serielle Schnittstelle nutzen (1)*

Ab Version 0.80 unterstützt Qemu die serielle Schnittstelle. Für den ersten Port Qemu so starten:



```
qemu ... -serial /dev/ttyS0
```


*serielle Schnittstelle nutzen (2)*

Qemu vor Version 0.80 unterstützt nicht direkt die serielle Schnittstelle, über den Umweg "Pseudoterminal" geht es aber doch.

Zunächst muss das Programm "slsnif" installiert werden, das die Ausgabe des Pseudoterminals von Qemu an die serielle Schnittstelle weiterleitet. Download über:

http://sourceforge.net/projects/slsnif/

Installieren:



```
tar zxvf slsnif*
cd slsnif*
./configure
make
make install
```

Nun muss Qemu mit Ausgabe auf Pseudo Terminal gestartet werden:



```
qemu ... --serial pty
```

In der Kommandozeile steht nun eine Pseudo Terminal Nr. in der Form "char device redirected to /dev/pts/5". Diese Nr. wird gebraucht für "slsnif". Im folgenden Beispiel wird Pseudo Terminal "5" mit Com 1  (ttyS0) verknüpft:



```
slsnif -p /dev/pts/5 /dev/ttyS0
```


Das ist natürlich zu kompliziert, durch das folgende Startscript kann man das ganze automatisieren:



```
qemu ... -serial pty > /tmp/qemu.log 2>&1 &
sleep 2
slsnif -s 115200 -p `cat /tmp/qemu.log | grep /dev/pts | cut -c 27-38` /dev/ttyS0
```

Der Parameter "-s" setzt die Baudrate. Das ganze jetzt noch 
in ein Script packen, z. B. "qemu.sh" und damit dann Qemu starten, fertig.

Getestet habe ich das mit einem seriellen Modem, es wurde einwandfrei von der Hardwarekennung erkannt.

Quelle: Qemu User Forum. Autor unbekannt, Ursprungspost durch Serverumzug verloren.


*Parallelport LPT*

Ab Version 0.80 kann Qemu den Parallelport nutzen:



```
qemu  ... -parallel /dev/parport0
```


*APM bei Win 2K&XP*

Der von Win 2K&XP normalerweise installierte APM-Treiber arbeitet nicht ganz korrekt mit Qemu zusammen. Dadurch wird Qemu beim Herunterfahren des Gastes nicht beendet, stattdessen erscheint die altbekannte Windows Meldung "Sie können das System jetzt ausschalten".

Lösen lässt sich das durch Nachinstallieren eines Treibers für die "herkömmliche NT-APM-Unterstützung":

Vorgehensweise 2K:

- Systemsteuerung
- Systemeigenschaften / Hardware / Hardware-Assistent
- Gerät hinzufügen bzw. Problem beheben
- Neues Gerät hinzufügen
- Nein, die Hardwarekomponenten selbst in der Liste auswählen
- Herkömmliche NT APM-Unterstützung

Vorgehensweise XP:

- Systemsteuerung
- Hardware / Weiter
- Ja, die Hardware wurde bereits angeschlossen
- Neue Hardware hinzufügen
- Hardware manuell aus einer Liste wählen
- Herkömmliche NT APM-Unterstützung

Bei den WinDOSen (9x, ME) arbeitet das Abschalten des virtuellen PCs hingegen korrekt.


*Absturz beim Hochfahren des Gastes durch ACPI-Probleme*

Falls es Probleme geben sollte, kann man versuchen, Qemu auch ohne ACPI zu starten:



```
qemu ... -no-acpi
```

Bei Windows Gästen ist dies derzeit die beste Wahl.

In der Systemsteuerung des Gastes sollte "Standard-PC" als Profil eingestellt, nicht "API-PC" (Systemsteuerung / System / Hardware / Geräte Manager / Computer).

Umstellen kann man das so:

- Auf ACPI-PC gehen (siehe oben)
- Eigenschaften / Treiber / Treiber aktualisieren / Treiber manuell aus Liste wählen / Standard PC
- Falls es Probleme gibt, ohne KVM bzw. im abgesicherten Modus starten

----------


## stefan.becker

Hier ein Screenshot von Qemu unter Fedora Core 2, Win98 als Gast:

----------


## stefan.becker

*qemu & 3D Desktop (compiz)*

Effekt: Das Qemu Fenster startet transparent.

Lösung: Vor dem Start von qemu folgenden Befehl eingeben:



```
export XLIB_SKIP_ARGB_VISUALS=1
```


*Win2K Disk Full Problem*

Installation klappt nicht, während des Ablaufs kommt eine Meldung, dass die Festplatte voll sei.

Die Installation starten mit:



```
qemu ... -win2k-hack
```

Der "Hack" ist nur temporär zur Gastinstallation. Nach der Installation von Windows 2000 den virtuellen PC nicht direkt neu starten, sondern beenden. Dann Qemu ohne den Parameter starten.


*Windows Update geht nicht (Win2K)*

Falls das Windows Update nicht funktioniert, mal testweise Qemu so starten:



```
qemu ... -win2k-hack
```

Das Problem scheint bedingt zu sein durch eine Abfrage der Plattengröße.
(Hinweis von Fred Meier)

----------


## stefan.becker

Bei den folgenden Netzwerkkonfigurationen ist immer ein Desktop-PC mit Internet Zugang die Ausgangsbasis, es wird hier keine Anbindung in ein umfangreicheres Netzwerk vorgenommen.

Als Netzwerktechnik in Qemu wird daher immer der Userstack (Parameter "*-net nic -net user*") verwendet. Dieses entspricht in VMWARE einer Kombination der "Host-Only-" (Zugriff auf Hostrechner) und "NAT-" (Internetzugriff) Technik.

*Hinweis:* Bei dieser Konfiguration wird die automatische Suche nach Ressourcen in der Netzwerkumgebung in einem Windows Gast nicht funktionieren. Hier muss stattdessen manuell die jeweilige Verknüpfung (also ein Samba Share bzw. der Drucker) angegeben werden.

Für eine erweiterte Netzwerkeinrichtung siehe 8.3).


*8.1) Drucken und Dateizugriff per Samba*

*8.1.1) Benutzung des Samba Servers des Hosts*

Bei dieser Methode wird der Samba Server des Hosts benutzt. Dieser muss natürlich vor Benutzung erstmal konfiguriert werden. Das ist zwar aufwändiger als die Methode aus 8.1.2), dafür ist allerdings auch die Benutzung der Drucker des Hosts als Netzwerkdrucker möglich.

Der Host hat im folgenden immer die TCP-Adresse 10.0.2.*2*.

Vorgehensweise:

- Zunächst Samba installieren (Pakete "samba" und "samba-common", Namen distributionsabhängig)


- Die Samba-Configdatei editieren (in der Regel "/etc/samba/smb.conf")

Folgende Einstellungen habe ich ausgehend von der Beispieldatei geändert:



```
[global]
...
printcap name = /etc/printcap
load printers = yes
cups options = raw
show add printer wizard = yes
printer admin = root, @dein_username
guest account = nobody
...

[printers]
   comment = All Printers
   printable = yes
   path = /tmp
   guest ok = yes

[qemu]
   comment = Temporary file space
   path = /tmp
   read only = no
   public = yes
```

Im Anhang findet sich die geänderte Basis-"smb.conf" (samba 3.x).


- Einen User in Samba anlegen 



```
smbpasswd -a stefan
```

Username und Kennwort genau wie der User, der später "qemu" startet. Dieser User muss später auch im Windows Gast mit gleichem Usernamen und Kennwort angemeldet werden. Obigen Befehl als root starten!


- Samba (neu) starten (/etc/init.d/smb restart) oder Rechner neu starten


- Qemu starten mit zusätzlichem Parameter



```
qemu ... -net nic -net user
```


- Einrichten des Netzwerkes im Windows-Gast

Installiert werden muss zusätzlich der Microsoft Client. In der Netzwerkumgebung taucht der Host nicht auf, es sollte aber trotzdem klappen.

Unter Win95/98/ME muss zusätzlich die Datei "c:\windows\lmhosts" erstelt werden. Inhalt: "10.0.2.2 smbserver".

In den Netzwerkeinstellungen muss die gleiche Arbeitsgruppe wie beim Sambaserver eingestellt sein, bei Tests habe ich *MYGROUP* verwendet.

Drucker: Netzwerkdrucker hinzufügen. Heisst der Drucker z. B. am Host "usblp0", muss als Anschluss "\\smbserver\usblp0" (Window 95/98/ME) bzw. "\\10.0.2.2\usblp0" (NT/2K/XP) gewählt werden. Abhängig von der Art der Queue muss der passende Treiber gewählt werden, bei einer Postscript Queue kann man z. B. den Apple Laserwriter nehmen.

SMB-Share: "net use x: \\smbserver\qemu" (95/98/ME) bzw. "net use x: \\10.0.2.2\qemu" (NT/2K/XP) in einer DOS-Kommandozeile eingeben. Damit kann man dann unter Laufwerk "x" auf das "/tmp"-Verzeichnis des Hosts zugreifen. Natürlich geht das ganze auch per Explorer/Extras/Netzlaufwerk verbinden.

Weitere Hinweise zur Einrichtung eines Samba-Servers siehe Samba-Howto:
http://www.linuxforen.de/forums/showthread.php?t=18923
http://gertranssmb3.berlios.de/output/

*Drucken: Hinweise zu NT/XP/2K*

Falls die obige Methode mit der Auswahl des Netzdruckers nicht geht, folgende Methode testen im Gast:

- lokalen Drucker mit Treiber passenden Typs installieren, Anschluss "lpt1:"

- Kommandozeile öffnen

- Befehl eingeben


```
net use lpt1 \\10.0.2.2\usblp0 /PERSISTENT:YES
```

"usblp0" muss natürlich durch die passende Druckerqueue ersetzt werden. 

Durch den net use-Befehl wird die lokale lpt1-Schnittstelle des Gastes auf den Netzdrucker umgelenkt. Warum es so geht? Keine Ahnung, aber es geht :-)


*Windows 9x+ME / Samba ab 3.20*

Nach Umstellung auf Samba ab 3.20 bekommt der Windows 98 Gast keine Netzwerkverbindung mehr zu Samba Shares. Es wird gemeldet, dass ein Kennwort gebraucht wird, obwohl User/Kennwort exakt das gleiche sind wie am Host.

Lösung: Die Optionen 

```
lanman auth = Yes 
client lanman auth = Yes
```

zur Samba [global] Konfiguration hinzufügen.


*Howtos zu Cups / Samba*

http://gertranssmb3.berlios.de/outpu...html#id2564439
http://www.linuxprinting.org/kpfeifl...1th-draft.html


*8.1.2) Benutzung des Qemu Samba Servers*

Bei dieser Methode wird der in Qemu integrierte Samba Server benutzt. Es ist keine Konfiguration notwendig, der Drucker ist dann nicht über Samba ansprechbar, kann aber über den Umweg Internet Printing Protocol / Cups benutzt werden, siehe dazu 8.1.3)

Der Host hat im folgenden immer die TCP-Adresse 10.0.2.*4*.

Ein Samba Server muss auch hier installiert sein (Pakete "samba", "samba-common", Name abhängig von der Distribution). Der Samba Server muss aber nicht konfiguriert werden.

Zunächst wird Qemu gestartet:



```
qemu ... -net nic -net user,"smb=/tmp"
```

Hierdurch wird das Verzeichnis "/tmp" im Windows Gast verfügbar, es kann natürlich auch jedes andere Verzeichnis eingebunden werden.

Dann muss im Gast die Zeile "10.0.2.4 smbserver" in die Datei "lmhosts" eingetragen werden (XP: "c:\windows\system32\drivers\etc", 2K: ""c:\winnt\system32\drivers\etc", 9x/ME: "c:\windows").

In einer Kommandozeile des Gasts kann man einfach eine Kommandozeile öffnen und folgenden Befehl eingeben.


```
net use x: \\smbserver\qemu /PERSISTENT:yes
```

Die Freigabe wird dann als Laufwerk "X:" eingebunden.


*8.1.3) Benutzung des Druckers über CUPS / Internet Printing Protocol*

Falls Cups am Host installiert ist, kann man darüber den Drucker auch ohne Samba nutzen. Dazu wird das sogenannte IPP-Internet Printing Protocol verwendet.

Windows 2000/XP:

- Drucker hinzufügen
- Netzwerkdrucker auswählen
- Verbinden mit URL auswählen
- Treiber für passendes Modell installieren

Als URL muss z. B. eingegeben werden:



```
http://10.0.2.2:631/printers/usblp0
```

"usblp0" ist zu ersetzen mit dem Druckernamen am Host.

Windows 9x/ME: Es muss ein zusätzliches Software Paket für den IPP-Support installiert werden. Download unter:

http://tig.csail.mit.edu/printing/windows/win9x.html

Software installieren, neu starten, dann Drucker wie oben mit der URL als Pfad eingeben.

Hinweis zur CUPS-Konfiguration, falls der Drucker im Gast nicht erkannt wird:
- Webbrowser am Host starten, URL eingeben: http://localhost:631
- Registerkarte Verwaltung
- Einstellungen setzen
- a) "Verteile publizierte Drucker welche mit diesem System verbunden sind"
- b) "Erlaube entfernte Verwaltung"


*8.2) Scannen über Netzwerk*

Es ist möglich, am Host angeschlossene Scanner im Windows Gast zu nutzen. Einzige Bedingung: Der Scanner muss in Sane eingerichtet sein und funktionieren.

Vorgehensweise:

- Sane und Scanner installieren & einrichten, z. B. nach folgendem Howto:

http://www.linuxforen.de/forums/show...hreadid=37567&

- Saned (Netzwerk Scanner Daemon) einrichten, z. B. nach folgendem Howto:

http://penguin-breeder.org/sane/saned/

- Windows Gast mit Netzwerk starten



```
qemu ... -net nic -net user
```

- Im Windows Gast die Sane-Twain-Bridge installieren. Download und Anleitung:

http://sanetwain.ozuzo.net/

In Windows ist Twain eine Standard-Scanner-Schnittstelle. SaneTwain emuliert diese und lenkt Twain-Zugriffe über das Netzwerk auf Host-Sane um.

Der Treiber besteht aus 2 Dateien:



```
copy sanetwain.ds c:\windows\twain_32
copy scanimage.exe c:\windows
```

Damit steht der Scanner im Windows Gast zur Verfügung. Zum Beispiel kann man dann direkt Windows OCR-Software nutzen.

Bei Suse Linux kann der Scanner über Yast2 komfortabel im Netzwerk freigegeben werden:
- Yast2 starten
- Hardware, Scanner starten
- Button "Andere", "Scannen via Netzwerk" wählen
- In "Zulässige Clients für saned die IP-Adresse des Windows Gastes eintragen
- "Vordefinierte Konfiguration" / "Konfiguration mit lokalem Host" wählen


*8.3) TUN/TAP Netzwerk*

Das oben benutzte User-Netzwerk hat einige Einschränkungen. Z. B. ist kein Ping vom Host zum Gast möglich, kein UDP etc. 

Durch die Benutzung eines (virtuellen) TUN/TAP-Adapters erhält der Qemu Gast eine vollständige TCP/IP Anbindung.

Dazu sind einige Vorarbeiten notwendig.

Die folgende Konfiguration setzt für den Internetzugang einen Router voraus, der auch gleichzeitig der DNS-Server ist.

Der Host erhält die feste IP-Adresse "10.0.0.1", der Gast "10.0.0.2".

*8.3.1) Kernel*

Der TUN/TAP-Adapter muss vom Kernel unterstützt werden. Bei aktuellen Distributionen ist dies sicher der Fall, so dass die folgenden Zeilen übersprungen werden können.

Für Linuxbastler: folgende Optionen müssen im Kernel aktiviert sein:

- CONFIG_TUN (Device Drivers / Network device support -> Universal TUN/TAP device driver support)
- CONFIG_IP_NF_CONNTRACK (Connection tracking)
- CONFIG_IP_NF_IPTABLES (IP tables support)
- CONFIG_IP_NF_NAT (Full NAT)

Laden des TUN-Moduls

Folgende Zeile in die Datei /etc/modprobe.conf einfügen:

"alias char-major-10-200 tun"

Anschließend als root "/sbin/depmod -a" ausführen.

*8.3.2) TUN-Device anlegen*

Nur falls die Datei "/dev/net/tun" nicht existiert bzw. ein älteres System ohne UDEV eingesetzt wird!

- login als root
- cd /dev
- mkdir net
- cd net
- mknod /dev/net/tun c 10 200
- chmod 666 tun

*8.3.3) Zugriffsrechte setzen*

Qemu selbst sollte als User gestartet werden. Einige Befehle zur Generierung des virtuellen TUN/TAP Adapters erfordern jedoch Root-Rechte.

Daher muss zunächst "sudo" installiert werden. Das ermöglicht das Starten von Programmen als User mit Root-Rechten.

In der Einstellungsdatei "/etc/sudoers" werden Programme angegeben, die vom User gestartet werden können. Daher folgende Zeilen anhängen ("username" durch eigenes Login ersetzen):



```
username  ALL=NOPASSWD:/sbin/ifconfig
username  ALL=NOPASSWD:/sbin/iptables
username  ALL=NOPASSWD:/bin/echo
username  ALL=NOPASSWD:/bin/chmod
```

*8.3.4) Qemu-Startscript*

Die Datei "/etc/qemu-ifup" erstellen:



```
#!/bin/sh
sudo /sbin/ifconfig $1 10.0.0.1 up
sudo /sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
sudo /bin/echo "1" >/proc/sys/net/ipv4/ip_forward
```

Die Schnittstelle "eth0" muss auf die Bezeichnung des Netzadapters des Hosts eingestellt werden (wlan0, eth1 etc.).

Braucht man keine Internetverbindung im Gast, reicht die 1. Zeile des Scriptes.

Das Script muss mit "chmod 755 /etc/qemu-ifup" ausführbar gemacht werden.

*8.3.5) Qemu starten*

*Einfache Methode (bis Kernel 2.6.17)*



```
sudo chmod 666 /dev/net/tun
qemu ... -net nic,vlan=0 -net tap,vlan=0,ifname=tap0
```

Beim Qemu-Start wird das Script "/etc/qemu-ifup" gestartet.

Hinweis von RayJones:

Rechte auf "/dev/net/tun" lassen sich alternativ so herstellen:

- Der Befehl "sudo chmod 666 /dev/net/tun" entfällt.
- Gruppe "net-tun" anlegen.
- Die Anwender, die qemu starten, dieser Gruppe zuordnen.
- Die Datei "/etc/udev/rules.d/50-udev-default.rules" im Editor öffnen.
- Eintrag für das Modul "tun" suchen und abändern:

Von: 

```
KERNEL=="tun", NAME="net/%k"
```

Nach: 

```
KERNEL=="tun", NAME="net/%k", GROUP="net-tun", MODE="0660"
```

*Ab Kernel 2.6.18*

*Alternative 1*

Man benötigt root-Rechte, um das Tun/Tap-Interface zu konfigurieren. Deshalb legen wir zunächst ein Script "qemu-tap" an mit folgendem Inhalt:



```
#!/bin/sh
# script to manage tap interface allocation
# for linux kernels >= 2.6.18

# set up a tap interface for qemu
# USERID - uid qemu is being run under.
USERID=`whoami`
iface=`sudo tunctl -b -u $USERID`

# generate a random mac address for the qemu nic
# shell script borrowed from user pheldens @ qemu forum
ranmac=$(echo -n DE:AD:BE:EF ; for i in `seq 1 2` ; \
do echo -n `echo ":$RANDOM$RANDOM" | cut -n -c -3` ;done)

# specify which NIC to use - see qemu.org for others
model=ne2k_pci

# start qemu with our parameters
qemu $@ -net nic,vlan=0,macaddr=$ranmac,model=$model \
        -net tap,vlan=0,ifname=$iface

# qemu has stopped - no longer using tap interface
sudo tunctl -d $iface &> /dev/null
```

Das Script per "chmod +x qemu-tap" ausführbar machen. Der Befehl "tunctl" muss in die Datei "/etc/sudoers" aufgenommen werden. Der Befehl "tunctl" befindet sich z. B. bei Suse im Paket "uml-utilities".

Statt "qemu -hda ... -net nic -net tap" lässt man im Startbefehl die net-Befehle weg und startet statt "qemu" dann "qemu-tap":



```
qemu-tap -hda ...
```

Quelle: http://qemu-buch.de/cgi-bin/moin.cgi...AskedQuestions

*Alternative 2*

Einrichtung wie oben (vor Kernel 2.6.18). Dann aber Qemu in "/etc/sudoers" eintragen und Qemu per "sudo qemu ..." starten.


*8.3.6) Einrichung im Gast*

Im Gast muss folgendes eingestellt werden:

- IP-Adresse: 10.0.0.2
- Maske: 255.0.0.0
- Gateway: 10.0.0.1
- DNS-Server: IP-Adresse des Routers (z. B. 192.168.2.1)

Drucker und Verzeichnisse des Hosts lassen sich am einfachsten per Samba nutzen. Dazu muss ein eigener Samba-Server eingerichtet werden, siehe oben.

Quelle: http://www.debian-administration.org/articles/40


*8.4) Zwischenablage über das virtuelle Netzwerk*

*8.4.1) ShareClip*

Download: http://share-clip.softpedia.com//

ShareClip ist eine reine Zwischenablage zwischen PCs über TCP/IP, kann also auch bei obiger Konfiguration als Zwischenablage zwischen Host und Gast verwendet werden.

Es gibt Clients für Linux, Windows und MacOS.

Das Programm muss am Host und am Gast gestartet werden. Beim Verbinden muss jeweils die IP-Adresse des Gegenparts angegeben werden. Im obigen Beispiel also:

- Host: 10.0.0.2
- Gast: 10.0.0.1

Wenn das Programm auf beiden Seiten läuft und die Verbindung steht, erfolgt die Synchronisation der Zwischenablage von Gast und Host automatisch.

*8.4.2) Qemu Guest Tools*

Homepage: http://wolfpackally.wo.funpic.de/qemu/qgt/

Paket besteht aus 3 Programmen:

Host: "host-linux", 
Gast: "guest-linux", "guestwin32"

Jedes der Programme wird mit der IP-Adresse des Hosts als Parameter gestartet (im Beispiel 10.0.0.1).

Beispiel für Qemu-Startdatei:


```
#!/bin/sh
sleep 5 && host-linux 10.0.0.1 &
qemu ... -net ...
killall -9 host-linux
```

Im Windows Gast das Programm über den Autostartordner beim Hochfahren starten mit dem Befehl:


```
guestwin32 10.0.0.1
```

Dieses Programm funktioniert übrigens auch ohne TUN/TAP mit dem User-Netzwerk.


*8.5) Virtuelle Netzwerke, "Bridged"-Netzwerke*

*8.5.1) Bridge*

Mit der folgenden Konfiguration taucht der Qemu-Gast als eigener PC im Netzwerk auf und hat vollen Zugriff auf alle Ressourcen.

Script "/etc/qemu-ifup" editieren:

```
#!/bin/sh
sudo /sbin/brctl addbr bri0
sudo /sbin/ifconfig eth0 0.0.0.0
sudo /sbin/brctl addif bri0 eth0
sudo /sbin/dhclient bri0
sudo /sbin/route add default gw 192.168.2.1
sudo /sbin/ifconfig $1 0.0.0.0 up
sudo /sbin/brctl addif bri0 $1
```

Script "/etc/qemu-ifdown" editieren:

```
#!/bin/sh
sudo /sbin/brctl delif bri0 $1
sudo /sbin/brctl delif bri0 eth0
sudo /sbin/ifconfig  bri0 down
sudo /sbin/brctl delbr bri0
sudo /sbin/dhclient eth0
sudo /sbin/route add default gw 192.168.2.1
```

IP-Adresse des Routers (hier 192.168.2.1) und Netwerkkarte (hier eth0) sind entsprechend anzupassen. Die Befehle müssen in der "/etc/sudoers" stehen. Das Paket "bridge-utils" muss installiert sein (brctl). Außerdem die Scripte ausführbar machen (chmod +x /etc/qemu-if*).

Qemu wird dann so gestartet:


```
qemu ... -net nic -net tap
```

Die Bridge wird also beim Starten des Gastes dynamisch angelegt (qemu-ifup) und beim Beenden des Gastes wieder abgebaut (qemu-ifdown).


*8.5.2) VDE*

Mit VDE kann man beliebige Netzwerkstrukturen generieren. Alles weitere siehe:

http://wiki.virtualsquare.org/index....sic_Networking


*8.5.3) Links*

http://lists.gnu.org/archive/html/qe.../msg00150.html
http://www.hants.lug.org.uk/cgi-bin/...QemuNetworking
http://wiki.qemu.org/download/qemu-doc.html / Kapitel "Network Emulation"
http://lists.gnu.org/archive/html/qe...DAJWgugtC1.txt


*8.6) ISDN-Netcapi*

Die ISDN-Karte des Hosts kann nicht direkt im Gast verwendet werden. Über folgenden Umweg kann man sie "mitbenutzen":

- Karte muss im Host funktionieren
- Netcapi-Server stellt über das virtuelle Netzwerk eine CAPI-Schicht zur Verfügung.
- Im Windows Client wird ein Netcapi-Client installiert

Beispiele:
- http://avm-capi4linux.berlios.de/
- http://www.shamrock.de/tools.htm#capiserv
- http://sourceforge.net/projects/capi20proxy


*8.7) Typ der emulierten Netzwerkkarte*

Standardmäßig emuliert Qemu eine ne2000-kompatible Netzwerkkarte. Es kann aber auch z. B. eine rtl8139-Karte emuliert werden:


```
qemu ... -net nic,vlan=0,model=rtl8139 -net tap,vlan=0,ifname=tap0
```

Als weitere Option wird eine Intel e1000-Gigabit-Karte emuliert:


```
qemu ... -net nic,vlan=0,model=e1000 -net tap,vlan=0,ifname=tap0
```

Treiber: http://www.intel.com/support/network/sb/cs-006120.htm

Weitere Optionen siehe "man qemu".


*8.8) Seamless Desktop*

Auch über Qemu/KVM lässt sich ein Seamless Desktop erreichen, also eine nahtlose Integration von Windows Anwendungen in den Linuxdesktop inkl. Mausrad und Zwischenablage.

Qemu wird dann im Hintergrund gestartet. Über das Paket "rdesktop" können dann einzelne Anwendungen oder auch das Windows Startmenü auf den Desktop gebracht werden.

Im Vergleich zu VMWARE (Unity Modus) oder VirtualBox erfordert die Lösung Bastelei, von daher sollte jemand, der das wirklich braucht, ein Produkt nehmen, womit das serienmäßig geht.

Grundvoraussetzungen auch hier:
- Ein Windows Gast mit Remote Desktop (z. B. XP-Professional, Vista, !kein XP-Home!)
- Qemu mit Hostonly Netzwerk oder Bridged, Ping in beiden Richtungen möglich. Das "User"-Netzwerk reicht nicht!

Zunächst muss Qemu im Hintergrund gestartet werden:


```
qemu ... -nographic -monitor "tcp:127.0.0.1:5502,server,nowait"
```

- "-nographic": Qemu läuft ohne grafische Ausgabe und kann auch ohne bzw. vor dem X-Server gestartet werden.
- "-monitor "tcp:127.0.0.1:5502,server,nowait"": Der Qemu-Monitor wird per telnet über Port 5502 ansprechbar.

Die Einrichtung des Gastes sowie die rdesktop Befehle sind analog zum Seamless Desktop mit VirtualBox: http://www.linuxforen.de/forums/show...07&postcount=8

Um während der Laufzeit den Gast zur Einbindung von Laufwerken etc. anzusprechen zu können, braucht man Zugriff auf den Qemu-Monitor. Dazu in einer Konsole folgenden Befehl starten:


```
telnet localhost 5502
```

----------


## stefan.becker

*9.1) Gegenüberstellung echtes Device / Diskimage*

Wie VMWARE kann Qemu grundsätzlich mit 2 verschiedenen Arten von "Festplatten" arbeiten:

*1) Echtes Device*

Qemu wird z. B. mit "qemu -hda /dev/hda1" gestartet. Damit wird das in der Partition "hda1" (IDE-Master am 1. Kanal, primäre Partition) installierte Betriebssystem gestartet.

Ich rate hiervon ab:

Nachteile:

- Die Verwaltung unterschiedlicher Hardwareprofile im gestarteten Windows ist notwendig, weil Qemu eben nur Hardware emuliert, und das Ergebnis ist nicht die im Original Hardware Profil verwaltete Hardware. Beispiel: Aus einer Terratec Soundkarte wird durch die Emulation eine SB 16. Also ist im Original Hardwareprofil die Terractec, im Qemu-Profil die SB 16.
- Es besteht die Gefahr der "Datenschrottung". Man muss höllisch aufpassen, wird "hda1" in Qemu gestartet, darf die Partition nicht gleichzeitig in Linux gemountet sein, sonst schreiben 2 Betriebssysteme parallel auf die Partition, was unweigerlich zum Datenverlust führt.

Vorteile:

- Keine 2. Installation nötig, was aber bei heutigen Plattengrößen wohl keine Rolle mehr spielen sollte.

Fazit: Nice to have, aber Finger davon!


*2) Diskimage*

Das Konzept der virtuellen Platte / Diskimage entspricht im wesentlichen der Vorgehensweise bei VMWARE und Bochs. Es ist eine große Containerdatei, die wie eine Festplatte angesprochen werden kann.

Beispiel: Eine Datei "win98.img" liegt unter "/tmp" und soll für Qemu als virtuelle Platte verwendet werden. Qemu wird dann gestartet mit "qemu -hda /tmp/win98.img".

Das Gastbetriebssystems merkt nichts davon, es hält das Diskimage für eine "echt" Festplatte, die wie das Original zur Benutzung partitioniert bzw. formatiert werden muss.

Vorteile:

- Abgeschottetes System ohne Auswirkung auf das Dateisystem des Hosts. Keine Gefahr der "Datenschrottung".
- Keine umständliche Verwaltung mehrerer Hardwareprofile.
- Die Installation ist auf andere Rechner übertragbar. Die emulierte Hardware ist ja immer gleich. Also einfach das Diskimage einmalig anlegen und dann auf beliebige Recher kopieren und dort mit Qemu starten, fertig. Die notwendige Anzahl freier Lizenzen des Gastbetriebssystems muss natürlich dabei beachtet werden.

Nachteile:

- 2. Installation notwendig, aber wie oben wohl kein Problem bei heutigen Plattengrößen.

Fazit: Genau das richtige, gefahrlos und flexibel in der Verwaltung.


*9.2) Anlegen eines Diskimages, verschiedene Arten*

Qemu bringt von Haus aus das Tool "qemu-img" mit zum Anlegen eines Diskimages. Mit "man qemu-img" erhält man eine ausführliche Hilfe, daher hier nur kurz 2 Beispiele:



```
qemu-img create -f raw winnt.img 1000M
```

Legt im aktuellen Verzeichnis eine 1000 MB (ca. 1 GB) große Datei an. Dieses *raw*-Image hat von vorneherein eine feste Größe im Gegensatz zum *qcow*-Image.



```
qemu-img create -f qcow winxp.img 10GB
```

Legt ein Image an, das maximal 10 GB groß werden kann. Zunächst ist die Datei nur einige KB groß. Aber bei jedem Schreibzugriff (also z. B. der Installation des Gastbetriebssystems) wächst das Image, bis die Maximalgröße von 10 GB erreicht ist

Vorteil qcow gegenüber raw: Nicht sofort viel Speicherplatz belegt.
Nachteil qcow gegenüber raw: Etwas schlechtere Performance, weil bei jedem Schreibzugriff erst noch die Datei vergrößert wird.

Wer auch andere Emulatoren testen will wie z. B. Bochs, sollte "RAW" nehmen, weil dieses Format kompatibel ist zwischen den beiden Emulatoren.


*9.3) Verwaltung von Diskimages*

Im folgenden einige Beispiele, um die Funktionen des "qemu-img" Befehls aufzuzeigen. Für alle Funktionen und Hilfe entweder "man qemu-img" (ausführlich) oder "qemu-img --help" (kurz).

*Info zu einem Image*



```
qemu-img info winnt.img
```

Zeigt Infos an zum Image wie Größe und Format.


*Diskimage konvertieren*



```
qemu-img convert -f raw nt4.img -O qcow -c nt4qcow.img
```

Das Diskimage "nt4.img" im RAW-Format wird ein QCOW-Image "nt4qcow.img" umgewandelt.

Der Parameter "-c" ist optional für eine Komprimierung des Zielimages anzugeben. Laut Hilfe ist die Komprimierung "read-only". Bedeutet: Das Zielimage ist zunächst komprimiert. Neue Daten werden aber wieder umkomrimiert geschrieben. Das ganze würde sich also lohnen, um nach der Installation von Software ein neues Image zu erzeugen, so dass die Sektoren der Software und des Betriebssystems komprimiert werden. Und diese Sektoren ändern sich in der Regel nicht, so dass man ein wesentlich kleineres Image erhält.

Ein weiteres Argument für eine Konvertierung des qcow-Images ist das Verhalten dieser Art generell. Das Image wird im Laufe der Zeit größer, aber freier Platz wird nicht immer freigegeben. Durch eine Konvertierung kann man eine neue, dann aber zusammenhängende und damit kleinere Disc neu erzeugen.

Mit diesem Befehl kann ein *VMWARE*-Image in ein Qemu-Image umgewandelt werden. Auch der umgekehrte Weg ist möglich.

Beim Konvertieren bleibt das Quellimage übrigens unverändert.


*Image shrinken mit Qemu Tools*

Ein direktes Shrinken gibt es nicht, nur den Umweg über das Konvertieren. Bsp.:


```
mv windows.img tmp.img
qemu-img convert tmp.img -O qcow -c windows.img
rm tmp.img
```

Für den besten Erfolg sollte bei Windows Gästen zuvor die Datenträgerbereinigung aufgerufen werden.

Außerdem sollte man freien Speicherplatz im Image mit Nullen überschreiben. Dafür gibt es folgende Tools:

a) Windows Gast

http://technet.microsoft.com/en-us/s.../bb897443.aspx

Im Gast folgenden Befehl starten:


```
sdelete -c c:
```

b) Linux Gast / ext2 und ext3

Im Gast muss das Tool "zerofree" installiert werden: http://intgat.tigress.co.uk/rmy/uml/index.html

Das Tool entpacken und mit "make" übersetzen. Dann  mit "init 1" in den Wartungsmodus gehen. Den Befehl "df" aufrufen, er zeigt die Partitionen an. Je Partition (Bsp.): 


```
umount /dev/sda1
zerofree /dev/sda1
```

Dann den Gast ganz herunterfahren (init 0) und das Shrinken aufrufen wie bei Windows Gast.


*Diskimages verschlüsseln*



```
qemu-img convert -f raw nt4.img -O qcow -e nt4qcow.img
```

Umwandlung wie oben. Durch den zusätzlichen Parameter *"-e"* wird das Zielimage verschlüsselt. Man muss zunächst ein bis zu 16 Zeichen langes Kennwort eingeben. Beim Starten von qemu muss man dann im Qemu-Monitor wiederum das Kennwort eingeben, um darauf zuzugreifen.

Ich habe es mit NT4 probiert. Allerdings bootet das Image nicht, während eine verschlüsselte Datenpartition problemlos ging.


*Snapshot eines Diskimages*

Wie VMWARE bietet Qemu eine Snapshot-Funktion.

"qemu -hda ...*-snapshot*" startet Qemu im Snapshot-Modus. Damit werden Änderungen im Dateisystem erstmal nur zwischengepuffert.

Wenn die Änderungen gespeichert werden sollen, muss man mit [Strg]-[Alt]-[2] zum Qemu-Monitor wechseln und dort "Commit" eingeben. Die Änderungen werden dann permanent im Diskimage aufgenommen.

Sollen die Änderungen hingegen verworfen werden, muss man Qemu nur beenden ohne den Befehl Commit und einfach neustarten.

Das ganze ist ideal zum Test einer Software-Installation. Starten mit "-snapshot" und Software installieren. Läuft das ganze, "Commit" eingeben und die neu installierte Software ist dauerhaft gespeichert. Geht es nicht, einfach Qemu beenden und neu starten, das Diskimage ist unverändert.

----------


## stefan.becker

Was jetzt noch fehlt, ist eine nette GUI zum Einrichten und Starten der virtuellen PCs.


*Qemulator*

Python/GTK/Glade basierend.

Homepage: http://www.heise.de/software/download/qemulator/39654


*QtEmu*

QT4-basierend.

Homepage: http://qtemu.org/
KDE-Apps: http://kde-apps.org/content/show.php?content=50780


*AQemu*

QT4-basierend.

http://sourceforge.net/projects/aqemu/

----------


## stefan.becker

Qemu gibt es auch für Windows. Z. B. könnte man so einen Linux Gast unter Windows parallel betreiben. Hier einige Links zum Thema:

*Download* (Windows-Installer / Binaries)

- http://homepage3.nifty.com/takeda-toshiya/


*Qemu selbst übersetzen*

http://wiki.qemu.org/download/qemu-doc.html#compilation / Kapitel "Compilation from the sources"


*Qemu starten* (Tipp von baumgartner)

1) Unter Windows müssen die Verweise auf das Bios vorhanden sein, also z. B.: -L "..\qemu"
2) Die Dateinamen müssen in der Windowsshell mit Hochkommas umklammert werden.

Ein fertiger Startbefehl sieht dann wie folgt aus:



```
qemu.exe -L "..\qemu" -hda "debian.img" -cdrom "debian_sarge_dvd1.iso" -user-net -boot d
```


*Diskimage anlegen*

Der Befehl lautet hier: "mkqemuimage.exe".

----------


## stefan.becker

Ab Qemu 0.81 ist ein VNC-Server integriert.

Beim Start von Qemu wird der Parameter "-vnc X" (X=Display-Nr., z. B. "1") angehängt. Qemu läuft dann im Hintergrund, startet also kein eigenes Fenster mit Grafikausgabe. 

Der Parameter "-usbdevice tablet" emuliert zusätzlich eine HID-USB-Maus. Ohne diesen Parameter hat die Maus einen Nachlaufeffekt.

Der Parameter "-monitor stdio" setzt den Qemu-Monitor auf die Konsole, von der aus Qemu gestartet wurde. Im VNC-Viewer geht das noch nicht, daher dieser Weg.



```
qemu ... -vnc localhost:1 -usb -usbdevice tablet -monitor stdio
```

An einem beliebigen Rechner im Netz muss dann ein VNC-Viewer gestartet werden für die grafische Ausgabe. Der VNC-Viewer muss mit der IP des Rechners, auf dem Qemu läuft, gestartet werden. Außerdem muss die beim Qemu-Start angegebene Display-Nr. angegeben werden. 



```
vncviewer localhost:1
```

Der Befehl "vncviewer" ist z. B. bei Fedora im Paket "vnc" (yum install vnc).


Was erreicht man dadurch?

Die grafische Ausgabe über VNC kann auf einem anderen Rechner erfolgen. Dadurch kann z. B. Qemu als besonderer Dienst auf einem Server starten und von einem anderen PC aus überwacht werden.


Links:
- VNC-Wiki: http://de.wikipedia.org/wiki/Vnc
- vnc-Pakete: http://rpmseek.com/rpm-pl/vnc.html?h...wer:FN:0:0:0:0

----------


## stefan.becker

*Was ist KVM?*

KVM steht für *K*ernel based *V*irtual *M*achine.

KVM besteht aus 2 Grund-Komponenten:

- einem Kernelmodul zur Beschleunigung bzw. als Hypervisor
- einem virtuellen PC auf der Basis von Qemu

Ein moderner Prozessor mit Unterstützung von Virtualisierungstechniken (Intel VT, AMD Pacifica) ist dabei Grundvoraussetzung.

Der Prozessor muss Intel VT oder AMD Pacifica unterstützen. Dies kann man mit folgendem Befehl prüfen:


```
egrep '^flags.*(vmx|svm)' /proc/cpuinfo
```

Falls der Prozessor ausreichend ist, gibt der Befehl eine Zeile aus wie:


```
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx mmxext fxsr_opt lm 3dnowext 3dnow up pni cx16 lahf_lm svm cr8legacy ts fid vid ttp tm stc
```

Ansonsten erfolgt keine Ausgabe.

Weiteres siehe FAQ: http://www.linux-kvm.org/page/FAQ

Das Kernelmodul von KVM ist ab Kernel 2.6.20 fester Bestandteil des Linux Kernels.


*13.1) Nutzen des Kernelmoduls im Standard-Qemu*

Voraussetzungen: 
- Aktuelle Distribution, Kernel >= 2.6.20 (getestet mit Opensuse 11.2)
- Aktuelles Qemu >= 0.11.x (falls selbst übersetzt => "./configure ... --enable-kvm")

Der Zugriff auf KVM erfodert entsprechende Rechte. Einfache Lösung: Qemu und Befehle zum Laden der Module (modprobe, rmmod) in die Date "/etc/sudoers" eintragen. 

Qemu-Start:


```
sudo /sbin/modprobe kvm
sudo /sbin/modprobe kvm_amd
sudo qemu ... --enable-kvm
sudo /sbin/rmmod kvm_amd
sudo /sbin/rmmod kvm
```

Statt "kvm_amd" bei einem Intel-Prozessor "kvm_intel" nehmen.


*13.2) KVM als Qemu-Ersatz*

Alternativ kann man auch KVM komplett installieren, das beinhaltet dann sowohl das Kernelmodul als auch ein angepasstes Qemu. Das Standard-Qemu muss dann also nicht installiert werden.

Aufgrund der QEMU-Basis können mit Qemu angelegte Images unter KVM 1:1 weiterverwendet werden. Alles in den vorherigen Kapiteln zu Qemu gesagte gilt auch 1:1 für KVM. 

Ansonsten ein paar Links, in den Howtos auf der Homepage ist die genaue Vorgehensweise zur Installation beschrieben.

- Releases: http://www.linux-kvm.org/page/Downloads
- SVN/Entwicklerversion: http://www.linux-kvm.org/page/Code
- Howto allgemein: http://www.linux-kvm.org/page/HOWTO

*GUIs ("Data Center Management")*

OpenQRM mit Xen Plugin: http://www.openqrm.com/
Convirt: http://gnomefiles.org/app.php/ConVirt

*Diverse Tools*

"Xenner" startet paravirtualisierte Linuxkernel mit KVM: http://kraxel.fedorapeople.org/xenner/

*Weitere Links*

Homepage: http://www.linux-kvm.org

Mailinglisten: http://www.linux-kvm.org/page/Lists%2C_IRC

Beschreibung auf Wikipedia: http://de.wikipedia.org/wiki/Kernel-...irtual_Machine

----------

