Virtualization Technologies

This is the home page for the "Virtualization Technologies" course. Here, you will find (in a badly-organised form) all the material, slides, and information needed to attend the course

For the previous edition of the course, check the old websites (2019.and 2021)

Lessons:

• First lesson: 2024/03/14, 9:30 -> 11:30
  • Introduction to the course
• Second lesson: 2024/04/02, 9:30 -> 11:30
  • Compute virtualization
• Third lesson: 2024/04/04, 9:30 -> 11:30
  • Intel VT-x (hosted and bare-metal hypervisor)
• Fourth lesson: 2024/04/11, 9:30 -> 11:30
  • Using KVM; example of I/O with KVM
  • Something more on I/O virtualization
• Fift lesson: 2024/04/18, 9:30 -> 11:30
  • VirtIO devices, again
  • Something about device passthrough
  • Introduction to containers
• Sixth lesson: 2024/04/23, 9:30 -> 11:30
  • Containers, again
  • Some experiments with Linux namespaces and similar
• Seventh lesson: 2024/04/30, 9:30 -> 11:30
  • On real-time virtual machines
• Eighth lesson: 2024/05/02, 9:30 -> 11:30
  • Multi-core real-time virtual machines
  • Something about unikernels

Project Ideas:

Remember: before starting to work on a project, contact me for details.

• Write a simple and minimalistic hypervisor for x86_64 or ARM using a programming language at your choice (WARNING! The hypervisor does not need to be complete; it just needs to show that you understood the basic virtualization technologies). You can use trap and emulate or hardware assisted virtualization, at your choice. If you also attended the Safe System Programming course, you can write it in Rust: it will count for both the courses.
• Write a minimalistic VM based on KVM, using a programming language at your choice. Implement only few simple devices (invented by you or based on virtio). If you also attended the Safe System Programming course, you can write it in Rust: it will count for both the courses.
• Implement some simple container runtime, as described in the course (and as better detailed here --- this tutorial is based on python, but you should use C, C++ or similar). If you also attended the Safe System Programming course, you can write it in Rust: it will count for both the courses.
• Perform some experiments with multi-processor real-time virtual machines. You can try to verify existing schedulability tests, or you can work on schedulability analysis, or you can try to implement global scheduling in the guest in a correct way
• Experimentally evaluate the real-time performance of (single-processor and multi-processor) virtual machines, considering both scheduling and latencies
• Write a simple Linux kernel modules that activates VT-x (or some form of hardware-assisted virtualization) and tries to run the host Linux kernel in non-root mode (something like vbh or similar). Enable EPT (or similar technologies) if possible.

Examples:

• Hypervisor examples:
  • Simple trap and emulate example (as a bare-metal hypervisor)
  • Simple example about using Intel's VT-x (as a hosted hypervisor or as a bare-metal hypervisor)
• Simple example about using KVM and more advanced example separating the guest in a different file
  • How to handle a guest doing I/O?
  • By modifying the example to handle the corresponding VM exits
• Some tests with containers and friends:
  • Minimalistic root filesystem for experimenting...
  • ...And a simple way to escape from a chroot!
  • Simple minimalistic quasi-container (notice: it still uses chroot for filesystem isolation, so you can break it!)
  • Better mini-container using pivot_root() (now, escaping is not so simple!!!)
  • Similar mini-container using a memory filesystem for the rootfs
  • Some instructions for using network interfaces in a container

Links:

• Some hypervisors:
  • The Xen hypervisor
  • A different kind of bare-metal hypervisor: Jailhouse
  • The ACRN hypervisor
  • A hosted hypervisor: KVM
• Example of OS-Level virtualization: Wine
• Software implementations of an Abstract Machine:
  • Bochs, using an interpreter for the implementation
  • QEMU, using a compiler (just-in-time compilation of machine instructions)
• The Open Container Initiative (OCI)
  • Its runtime specification
  • Its format specification
  • Its new distribution specification
• How to add networking interfaces to a container without having administrator capabilities. This is based on creating a TAP interface inside the container (possible because of the user namespace).
• Example of container abstraction (OCI compliant) implemented through a hypervisor
• Discussion about container runtimes (implemented in Rust)
• Patchset implementing hierarchical scheduling for containers (real-time control group scheduling though SCHED_DEADLINE)
• Tool to design periodic servers for the root scheduler in hierarchical systems (it implements the Compositional Scheduling Framework analysis)
• Some other tools and scripts that can be used to design, analyze and run KVM-based virtual machines
• Scripts to measure the latencies introduced by KVM and Xen
• Some lightweight VMs / VMMs based on KVM:
  • QEMU's microvm
  • The Intel cloud hypervisor
  • Amazon's FireCracker
  • kvmtool
  • An example of unikernel hypervisor