server/kvm.py

#!/usr/bin/python
#
# Copyright 2007 Google Inc. Released under the GPL v2

"""
This module defines the KVM class

	KVM: a KVM virtual machine monitor
"""

__author__ = """
mbligh@google.com (Martin J. Bligh),
poirier@google.com (Benjamin Poirier),
stutsman@google.com (Ryan Stutsman)
"""

import os

import hypervisor
import utils
import hosts

from common.error import *


_qemu_ifup_script= """\
#!/bin/sh
# $1 is the name of the new qemu tap interface

ifconfig $1 0.0.0.0 promisc up
brctl addif br0 $1
"""

_check_process_script= """\
if [ -f "%(pid_file_name)s" ]
then
	pid=$(cat "%(pid_file_name)s")
	if [ -L /proc/$pid/exe ] && stat /proc/$pid/exe | 
		grep -q --  "-> \`%(qemu_binary)s\'\$"
	then
		echo "process present"
	else
		rm -f "%(pid_file_name)s"
		rm -f "%(monitor_file_name)s"
	fi
fi
"""

_hard_reset_script= """\
import socket

monitor_socket= socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
monitor_socket.connect("%(monitor_file_name)s")
monitor_socket.send("system_reset\\n")\n')
"""

_remove_modules_script= """\
if $(grep -q "^kvm_intel [[:digit:]]\+ 0" /proc/modules)
then
	rmmod kvm-intel
fi

if $(grep -q "^kvm_amd [[:digit:]]\+ 0" /proc/modules)
then
	rmmod kvm-amd
fi

if $(grep -q "^kvm [[:digit:]]\+ 0" /proc/modules)
then
	rmmod kvm
fi
"""


class KVM(hypervisor.Hypervisor):
	"""
	This class represents a KVM virtual machine monitor.

	Implementation details:
	This is a leaf class in an abstract class hierarchy, it must 
	implement the unimplemented methods in parent classes.
	"""

	build_dir= None
	pid_dir= None
	support_dir= None
	addresses= []
	insert_modules= True
	modules= {}


	def __del__(self):
		"""
		Destroy a KVM object.

		Guests managed by this hypervisor that are still running will 
		be killed.
		"""
		self.deinitialize()


	def _insert_modules(self):
		"""
		Insert the kvm modules into the kernel.

		The modules inserted are the ones from the build directory, NOT 
		the ones from the kernel.

		This function should only be called after install(). It will
		check that the modules are not already loaded before attempting
		to insert them.
		"""
		cpu_flags= self.host.run('cat /proc/cpuinfo | '
			'grep -e "^flags" | head -1 | cut -d " " -f 2-'
			).stdout.strip()

		if cpu_flags.find('vmx') != -1:
			module_type= "intel"
		elif cpu_flags.find('svm') != -1:
			module_type= "amd"
		else:
			raise AutoservVirtError("No harware "
				"virtualization extensions found, "
				"KVM cannot run")

		self.host.run('if ! $(grep -q "^kvm " /proc/modules); '
			'then insmod "%s"; fi' % (utils.sh_escape(
			os.path.join(self.build_dir, "kernel/kvm.ko")),))
		if module_type == "intel":
			self.host.run('if ! $(grep -q "^kvm_intel " '
				'/proc/modules); then insmod "%s"; fi' % 
				(utils.sh_escape(os.path.join(self.build_dir, 
				"kernel/kvm-intel.ko")),))
		elif module_type == "amd":
			self.host.run('if ! $(grep -q "^kvm_amd " '
				'/proc/modules); then insmod "%s"; fi' % 
				(utils.sh_escape(os.path.join(self.build_dir, 
				"kernel/kvm-amd.ko")),))


	def _remove_modules(self):
		"""
		Remove the kvm modules from the kernel.

		This function checks that they're not in use before trying to 
		remove them.
		"""
		self.host.run(_remove_modules_script)


	def install(self, addresses, build=True, insert_modules=True, syncdir=None):
		"""
		Compile the kvm software on the host that the object was 
		initialized with.

		The kvm kernel modules are compiled, for this, the kernel
		sources must be available. A custom qemu is also compiled.
		Note that 'make install' is not run, the kernel modules and 
		qemu are run from where they were built, therefore not 
		conflicting with what might already be installed.

		Args:
			addresses: a list of dict entries of the form 
				{"mac" : "xx:xx:xx:xx:xx:xx", 
				"ip" : "yyy.yyy.yyy.yyy"} where x and y 
				are replaced with sensible values. The ip 
				address may be a hostname or an IPv6 instead.

				When a new virtual machine is created, the 
				first available entry in that list will be 
				used. The network card in the virtual machine 
				will be assigned the specified mac address and
				autoserv will use the specified ip address to 
				connect to the virtual host via ssh. The virtual
				machine os must therefore be configured to 
				configure its network with the ip corresponding 
				to the mac.
			build: build kvm from the source material, if False,
				it is assumed that the package contains the 
				source tree after a 'make'.
			insert_modules: build kvm modules from the source 
				material and insert them. Otherwise, the 
				running kernel is assumed to already have
				kvm support and nothing will be done concerning
				the modules.

		TODO(poirier): check dependencies before building
		kvm needs:
		libasound2-dev
		libsdl1.2-dev (or configure qemu with --disable-gfx-check, how?)
		bridge-utils
		"""
		self.addresses= [
			{"mac" : address["mac"], 
			"ip" : address["ip"],
			"is_used" : False} for address in addresses]

		self.build_dir = self.host.get_tmp_dir()
		self.support_dir= self.host.get_tmp_dir()

		self.host.run('echo "%s" > "%s"' % (
			utils.sh_escape(_qemu_ifup_script),
			utils.sh_escape(os.path.join(self.support_dir, 
				"qemu-ifup.sh")),))
		self.host.run('chmod a+x "%s"' % (
			utils.sh_escape(os.path.join(self.support_dir, 
				"qemu-ifup.sh")),))

		self.host.send_file(self.source_material, self.build_dir)
		remote_source_material= os.path.join(self.build_dir, 
				os.path.basename(self.source_material))

		self.build_dir= utils.unarchive(self.host, 
			remote_source_material)

		if insert_modules:
			configure_modules= ""
			self.insert_modules= True
		else:
			configure_modules= "--with-patched-kernel "
			self.insert_modules= False

		# build
		if build:
			try:
				self.host.run('make -C "%s" clean' % (
					utils.sh_escape(self.build_dir),))
			except AutoservRunError:
				# directory was already clean and contained 
				# no makefile
				pass
			self.host.run('cd "%s" && ./configure %s' % (
				utils.sh_escape(self.build_dir), 
				configure_modules,))
			if syncdir:
				cmd = 'cd "%s/kernel" && make sync LINUX=%s' % (
				utils.sh_escape(self.build_dir),
				utils.sh_escape(syncdir))
				self.host.run(cmd)
			self.host.run('make -j%d -C "%s"' % (
				self.host.get_num_cpu() * 2, 
				utils.sh_escape(self.build_dir),))
			# remember path to modules
			self.modules['kvm'] = "%s" %(
				utils.sh_escape(os.path.join(self.build_dir, 
				"kernel/kvm.ko")))
			self.modules['kvm-intel'] = "%s" %(
				utils.sh_escape(os.path.join(self.build_dir, 
				"kernel/kvm-intel.ko")))
			self.modules['kvm-amd'] = "%s" %(
				utils.sh_escape(os.path.join(self.build_dir, 
				"kernel/kvm-amd.ko")))
			print self.modules

		self.initialize()


	def initialize(self):
		"""
		Initialize the hypervisor.

		Loads needed kernel modules and creates temporary directories.
		The logic is that you could compile once and 
		initialize - deinitialize many times. But why you would do that
		has yet to be figured.

		Raises:
			AutoservVirtError: cpuid doesn't report virtualization 
				extentions (vmx for intel or svm for amd), in
				this case, kvm cannot run.
		"""
		self.pid_dir= self.host.get_tmp_dir()

		if self.insert_modules:
			self._remove_modules()
			self._insert_modules()


	def deinitialize(self):
		"""
		Terminate the hypervisor.

		Kill all the virtual machines that are still running and
		unload the kernel modules.
		"""
		self.refresh_guests()
		for address in self.addresses:
			if address["is_used"]:
				self.delete_guest(address["ip"])
		self.pid_dir= None

		if self.insert_modules:
			self._remove_modules()


	def new_guest(self, qemu_options):
		"""
		Start a new guest ("virtual machine").

		Returns:
			The ip that was picked from the list supplied to 
			install() and assigned to this guest.

		Raises:
			AutoservVirtError: no more addresses are available.
		"""
		for address in self.addresses:
			if not address["is_used"]:
				break
		else:
			raise AutoservVirtError(
				"No more addresses available")

		retval= self.host.run(
			'%s'
			# this is the line of options that can be modified
			' %s '
			'-pidfile "%s" -daemonize -nographic '
			#~ '-serial telnet::4444,server '
			'-monitor unix:"%s",server,nowait '
			'-net nic,macaddr="%s" -net tap,script="%s" -L "%s"' % (
			utils.sh_escape(os.path.join(
				self.build_dir, 
				"qemu/x86_64-softmmu/qemu-system-x86_64")),
			qemu_options, 
			utils.sh_escape(os.path.join(
				self.pid_dir, 
				"vhost%s_pid" % (address["ip"],))), 
			utils.sh_escape(os.path.join(
				self.pid_dir, 
				"vhost%s_monitor" % (address["ip"],))), 
			utils.sh_escape(address["mac"]),
			utils.sh_escape(os.path.join(
				self.support_dir, 
				"qemu-ifup.sh")),
			utils.sh_escape(os.path.join(
				self.build_dir, 
				"qemu/pc-bios")),))

		address["is_used"]= True
		return address["ip"]


	def refresh_guests(self):
		"""
		Refresh the list of guests addresses.

		The is_used status will be updated according to the presence
		of the process specified in the pid file that was written when
		the virtual machine was started.

		TODO(poirier): there are a lot of race conditions in this code
		because the process might terminate on its own anywhere in 
		between
		"""
		for address in self.addresses:
			if address["is_used"]:
				pid_file_name= utils.sh_escape(os.path.join(
					self.pid_dir, 
					"vhost%s_pid" % (address["ip"],)))
				monitor_file_name= utils.sh_escape(os.path.join(
					self.pid_dir, 
					"vhost%s_monitor" % (address["ip"],)))
				retval= self.host.run(
					_check_process_script % {
					"pid_file_name" : pid_file_name, 
					"monitor_file_name" : monitor_file_name,
					"qemu_binary" : utils.sh_escape(
						os.path.join(self.build_dir, 
						"qemu/x86_64-softmmu/"
						"qemu-system-x86_64")),})
				if (retval.stdout.strip() != 
					"process present"):
					address["is_used"]= False


	def delete_guest(self, guest_hostname):
		"""
		Terminate a virtual machine.

		Args:
			guest_hostname: the ip (as it was specified in the 
				address list given to install()) of the guest 
				to terminate.

		Raises:
			AutoservVirtError: the guest_hostname argument is
				invalid

		TODO(poirier): is there a difference in qemu between 
		sending SIGTEM or quitting from the monitor?
		TODO(poirier): there are a lot of race conditions in this code
		because the process might terminate on its own anywhere in 
		between
		"""
		for address in self.addresses:
			if address["ip"] == guest_hostname:
				if address["is_used"]:
					break
				else:
					# Will happen if deinitialize() is 
					# called while guest objects still
					# exit and these are del'ed after.
					# In that situation, nothing is to 
					# be done here, don't throw an error
					# either because it will print an
					# ugly message during garbage 
					# collection. The solution would be to
					# delete the guest objects before 
					# calling deinitialize(), this can't be
					# done by the KVM class, it has no 
					# reference to those objects and it 
					# cannot have any either. The Guest 
					# objects already need to have a 
					# reference to their managing 
					# hypervisor. If the hypervisor had a 
					# reference to the Guest objects it 
					# manages, it would create a circular 
					# reference and those objects would 
					# not be elligible for garbage 
					# collection. In turn, this means that 
					# the KVM object would not be 
					# automatically del'ed at the end of 
					# the program and guests that are still
					# running would be left unattended.
					# Note that this circular reference 
					# problem could be avoided by using 
					# weakref's in class KVM but the 
					# control file will most likely also
					# have references to the guests.
					return
		else:
			raise AutoservVirtError("Unknown guest hostname")

		pid_file_name= utils.sh_escape(os.path.join(self.pid_dir, 
			"vhost%s_pid" % (address["ip"],)))
		monitor_file_name= utils.sh_escape(os.path.join(self.pid_dir, 
			"vhost%s_monitor" % (address["ip"],)))

		retval= self.host.run(
			_check_process_script % {
			"pid_file_name" : pid_file_name, 
			"monitor_file_name" : monitor_file_name, 
			"qemu_binary" : utils.sh_escape(os.path.join(
				self.build_dir, 
				"qemu/x86_64-softmmu/qemu-system-x86_64")),})
		if retval.stdout.strip() == "process present":
			self.host.run('kill $(cat "%s")' %(
				pid_file_name,))
			self.host.run('rm -f "%s"' %(
				pid_file_name,))
			self.host.run('rm -f "%s"' %(
				monitor_file_name,))
		address["is_used"]= False


	def reset_guest(self, guest_hostname):
		"""
		Perform a hard reset on a virtual machine.

		Args:
			guest_hostname: the ip (as it was specified in the 
				address list given to install()) of the guest 
				to terminate.

		Raises:
			AutoservVirtError: the guest_hostname argument is
				invalid
		"""
		for address in self.addresses:
			if address["ip"] is guest_hostname:
				if address["is_used"]:
					break
				else:
					raise AutoservVirtError("guest "
						"hostname not in use")
		else:
			raise AutoservVirtError("Unknown guest hostname")

		monitor_file_name= utils.sh_escape(os.path.join(self.pid_dir, 
			"vhost%s_monitor" % (address["ip"],)))

		self.host.run('python -c "%s"' % (utils.sh_escape(
			_hard_reset_script % {
			"monitor_file_name" : monitor_file_name,}),))