CSL862 : Virtualization and Cloud Computing : HW3 : Hardware Virtualization Techniques

In this homework, you will study KVM, a hardware-assisted VMM.

Building and Running Linux/KVM

You will need a 64-bit x86 machine with a processor which supports Intel-VT or AMD-V hardware virtualization extensions. You will need root privileges on this machine. Download the latest version of the Linux kernel from kernel.org and copy it to /usr/src directory.

Building Linux Kernel

Untar the linux tarball using, tar -xvf linux-x.x.xx.x.tar.bz2
cd linux-x.x.xx.x folder
Get into the root shell, using sudo su
Copy your current kernel configuration file (/boot/config-x.x.xx.x) to the current working directory (linux-x.x.xx.x) and rename it to .config.
- cp /boot/config-`uname -r` ./.config
Install libncurses5-dev: apt-get install libncurses5-dev.
Run command: make menuconfig.
Select option Load an Alternate Configuration File. You will be prompted for .config. Click Yes.
Go to Virtualization, and select all KVM options to be compiled in the kernel as modules (M).
Go to General Setup, select option Local version- append to kernel release, and put suffix -custom, for example
Exit from the configuration menu. You will be prompted to save your configuration to .config. Select Yes.
Optionally, to make the build process faster, set environment variable CONCURRENCY_LEVEL to be the one greater than the number of processors on your system.
- export CONCURRENCY_LEVEL=3
make -j $CONCURRENCY_LEVEL && make_modules install && make install && make headers_install
Wait for minutes/hours (depends on your system)
Move to /boot directory and run: makeinitramfs -o initrd.img-new_kernel_version new_kernel_version. The new_kernel_version is appended to newly created vmlinuz-x.x.xx.x img, for example
Configure your bootloader. For example, uun update-grub if using GRUB on Ubuntu.
Congrats, you are done. Reboot, select your newly compiled kernel and enjoy.

Running Qemu/KVM

Run KVM by using the --enable-kvm flag to your Qemu commandline. For example: qemu --enable-kvm linux.img

Recompile KVM Module

For this assignment, you will be making changes to the KVM module compiled as part of the kernel. We give you some instructions on how to compile and test your changes to the KVM module.

Make changes to your kvm module.
For convenience, create a shell script (e.g., call it recompile) in your linux source folder /usr/src/linux-x.x.xx.x. Here are the contents of the recompile shell script:
```
make M=arch/x86/kvm
rmmod kvm_intel kvm
cp arch/x86/kvm/*ko /lib/modules/LINUX_KERNEL_VERSION/kernel/arch/x86/kvm/
modprobe kvm_intel
modprobe kvm
```
Make the script executable: chmod +x recompile
Run the script with root privileges to recompile your kernel with new KVM module. The modprobe commands in the script reload the modules (without the need to reboot): sudo ./recompile

Creating a VM Disk Image

Here is a page with more information. Here are some examples:

qemu-img create -f qcow2 winxp.img 3G
qemu -m 256 -hda winxp.img -cdrom winxpsp2.iso -boot d
qemu -m 256 -hda winxp.img -cdrom /dev/cdrom -boot d
qemu -m 256 -hda winxp.img -cdrom winxpsp2.iso -kernel-kqemu
qemu-system-x86_64 -m 256 -hda winxp.img -cdrom winxpsp2.iso -kernel-kqemu

--enable-kvm

Exercises

Create a VM Image and run it using KVM.
Count the number of VM-exits due to external interrupts any VM run. You will need to modify code in the KVM kernel module.
Implement a new emulated output device OUTPORT0. This device prints all the characters sent to port 0 using outb instruction to the standard output of the QEMU process. For example, the guest can use the following code to print "hello world" to the standard output of the Qemu process:
```
outb $0, $104
outb $0, $101
outb $0, $108
outb $0, $108
outb $0, $111
outb $0, $20
outb $0, $119
outb $0, $111
outb $0, $114
outb $0, $118
outb $0, $100
```
Notice that the second argument in each instruction is the ASCII code of the corresponding character in the string "hello world". You will need to make changes to the Qemu source code to implement this device. Your guest will exit on each I/O access to this device.
Next, make this device memory-mapped. In other words, instead of listening to port 0, the device should listen to a particular physical memory address. Now, to print "hello world", the guest must execute the following:
```
movb $104, VA
movb $101, VA
movb $108, VA
movb $108, VA
movb $111, VA
movb $20 , VA
movb $119, VA
movb $111, VA
movb $114, VA
movb $118, VA
movb $100, VA
```
For this to work, the virtual address VA must be mapped in the guest to the physical address corresponding to the device register.
Make the emulation of this device exitless by emulating it using a sidecore. You will need to map a shared page between the guest and the device-emulation process. Use the ideas detailed in the vIOMMU paper[1] on sidecore emulation.

References

[1] vIOMMU: Efficient IOMMU Emulation, N. Amit, M. Ben-Yehuda, D. Tsafrir, A. Schuster. USENIX ATC 2011