TODO: Difference between revisions

From KVM
(timestamp is monotonic)
(rearrange emulator related items)
Line 9: Line 9:
The following smaller scale tasks can be a nice entry point to someone wishing to get involved:  
The following smaller scale tasks can be a nice entry point to someone wishing to get involved:  


* Trap #UD and emulate sysenter/syscall/sysret/sysexit.  These instructions don't exist on all cpus in all modes, so they hinder cross-vendor migration (in progress)
* Consolidate the inb/outb emulation helpers into x86_emulate.c
* The spinlock->mutex conversion exposes many possiblities of code simplifications, where previously atomic    context is now regular code.
* The spinlock->mutex conversion exposes many possiblities of code simplifications, where previously atomic    context is now regular code.
* Store command line options in an empty snapshot in a qcow2 format image file.  This allows an image file to be self contained: <code><nowiki>qemu file.img</nowiki></code> should be enough to launch a fully configured virtual machine.
* Store command line options in an empty snapshot in a qcow2 format image file.  This allows an image file to be self contained: <code><nowiki>qemu file.img</nowiki></code> should be enough to launch a fully configured virtual machine.
Line 23: Line 21:


x86 emulator updates:
x86 emulator updates:
* Trap #UD and emulate sysenter/syscall/sysret/sysexit.  These instructions don't exist on all cpus in all modes, so they hinder cross-vendor migration (in progress)
* Consolidate the inb/outb emulation helpers into x86_emulate.c
* Currently, the emulator is called twice for each instruction that reads mmio memory: once to fetch the operand
* Currently, the emulator is called twice for each instruction that reads mmio memory: once to fetch the operand
  and once to execute.  Split the emulator into two functions: one to decode into the emulation context, and
  and once to execute.  Split the emulator into two functions: one to decode into the emulation context, and

Revision as of 10:37, 30 July 2007

TODO


The following items need some love. Please post to the list if you are interested in helping out:

  • Real mode support: VT support for real mode is terrible, so we need to do it in software. This means extending the x86 emulator (x86_emulate.c) to handle more instructions, and changing the execution loop to call the emulator for real mode (in progress).
  • Move the apic/ioapic/pic/pit emulation into the kernel. This will simplify in-kernel paravirtualized devices (as there is no need to exit to userspace to inject an interrupt) and guest SMP (in progress).
  • Emulate the architectural performance monitor counters/msrs, for Linux nmi watchdog support.

The following smaller scale tasks can be a nice entry point to someone wishing to get involved:

  • The spinlock->mutex conversion exposes many possiblities of code simplifications, where previously atomic context is now regular code.
  • Store command line options in an empty snapshot in a qcow2 format image file. This allows an image file to be self contained: qemu file.img should be enough to launch a fully configured virtual machine.

MMU related:

  • Attach kvm memory to a Linux address_space so that guest memory can be paged out (patch exists for alternative approach to guest paging).
  • Support large pages (in conjunction with the item above) so that if the guest uses a large page mapping and the guest memory is backed by hugetlbfs, a large-page pte is created.
  • Improve mmu page eviction algorithm (currently FIFO, change to approximate LRU).
  • Add a read-only memory type.
  • Implement AM20 for dos and the like.
  • Implement direct page tables on paravirt_ops enabled Linux guests (in progress)

x86 emulator updates:

  • Trap #UD and emulate sysenter/syscall/sysret/sysexit. These instructions don't exist on all cpus in all modes, so they hinder cross-vendor migration (in progress)
  • Consolidate the inb/outb emulation helpers into x86_emulate.c
  • Currently, the emulator is called twice for each instruction that reads mmio memory: once to fetch the operand
and once to execute.  Split the emulator into two functions: one to decode into the emulation context, and
the other to actually execute the instruction.

For the adventurous:

  • Emulate the VT and SVM instructions, so that kvm can run in a virtual machine. Test by running a VM in a VT guest in an SVM guest on VT hardware, as well as running a VM in an SVM guest in a VT guest on SVM hardware.
  • Emulate the VT and SVM instruction sets on qemu. This would be very beneficial to debugging kvm.
  • Keep this TODO up to date