code.grnet.gr Git - ganeti-local/blob - lib/hypervisor/hv_kvm.py

   1 #
   2 #
   3
   4 # Copyright (C) 2008, 2009, 2010, 2011, 2012 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """KVM hypervisor
  23
  24 """
  25
  26 import errno
  27 import os
  28 import os.path
  29 import re
  30 import tempfile
  31 import time
  32 import logging
  33 import pwd
  34 import struct
  35 import fcntl
  36 import shutil
  37 import socket
  38 import stat
  39 import StringIO
  40 try:
  41   import affinity   # pylint: disable=F0401
  42 except ImportError:
  43   affinity = None
  44
  45 from ganeti import utils
  46 from ganeti import constants
  47 from ganeti import errors
  48 from ganeti import serializer
  49 from ganeti import objects
  50 from ganeti import uidpool
  51 from ganeti import ssconf
  52 from ganeti.hypervisor import hv_base
  53 from ganeti import netutils
  54 from ganeti.utils import wrapper as utils_wrapper
  55
  56
  57 _KVM_NETWORK_SCRIPT = constants.SYSCONFDIR + "/ganeti/kvm-vif-bridge"
  58 _KVM_START_PAUSED_FLAG = "-S"
  59
  60 # TUN/TAP driver constants, taken from <linux/if_tun.h>
  61 # They are architecture-independent and already hardcoded in qemu-kvm source,
  62 # so we can safely include them here.
  63 TUNSETIFF = 0x400454ca
  64 TUNGETIFF = 0x800454d2
  65 TUNGETFEATURES = 0x800454cf
  66 IFF_TAP = 0x0002
  67 IFF_NO_PI = 0x1000
  68 IFF_VNET_HDR = 0x4000
  69
  70
  71 def _ProbeTapVnetHdr(fd):
  72   """Check whether to enable the IFF_VNET_HDR flag.
  73
  74   To do this, _all_ of the following conditions must be met:
  75    1. TUNGETFEATURES ioctl() *must* be implemented
  76    2. TUNGETFEATURES ioctl() result *must* contain the IFF_VNET_HDR flag
  77    3. TUNGETIFF ioctl() *must* be implemented; reading the kernel code in
  78       drivers/net/tun.c there is no way to test this until after the tap device
  79       has been created using TUNSETIFF, and there is no way to change the
  80       IFF_VNET_HDR flag after creating the interface, catch-22! However both
  81       TUNGETIFF and TUNGETFEATURES were introduced in kernel version 2.6.27,
  82       thus we can expect TUNGETIFF to be present if TUNGETFEATURES is.
  83
  84    @type fd: int
  85    @param fd: the file descriptor of /dev/net/tun
  86
  87   """
  88   req = struct.pack("I", 0)
  89   try:
  90     res = fcntl.ioctl(fd, TUNGETFEATURES, req)
  91   except EnvironmentError:
  92     logging.warning("TUNGETFEATURES ioctl() not implemented")
  93     return False
  94
  95   tunflags = struct.unpack("I", res)[0]
  96   if tunflags & IFF_VNET_HDR:
  97     return True
  98   else:
  99     logging.warning("Host does not support IFF_VNET_HDR, not enabling")
 100     return False
 101
 102
 103 def _OpenTap(vnet_hdr=True):
 104   """Open a new tap device and return its file descriptor.
 105
 106   This is intended to be used by a qemu-type hypervisor together with the -net
 107   tap,fd=<fd> command line parameter.
 108
 109   @type vnet_hdr: boolean
 110   @param vnet_hdr: Enable the VNET Header
 111   @return: (ifname, tapfd)
 112   @rtype: tuple
 113
 114   """
 115   try:
 116     tapfd = os.open("/dev/net/tun", os.O_RDWR)
 117   except EnvironmentError:
 118     raise errors.HypervisorError("Failed to open /dev/net/tun")
 119
 120   flags = IFF_TAP | IFF_NO_PI
 121
 122   if vnet_hdr and _ProbeTapVnetHdr(tapfd):
 123     flags |= IFF_VNET_HDR
 124
 125   # The struct ifreq ioctl request (see netdevice(7))
 126   ifr = struct.pack("16sh", "", flags)
 127
 128   try:
 129     res = fcntl.ioctl(tapfd, TUNSETIFF, ifr)
 130   except EnvironmentError:
 131     raise errors.HypervisorError("Failed to allocate a new TAP device")
 132
 133   # Get the interface name from the ioctl
 134   ifname = struct.unpack("16sh", res)[0].strip("\x00")
 135   return (ifname, tapfd)
 136
 137
 138 class QmpMessage:
 139   """QEMU Messaging Protocol (QMP) message.
 140
 141   """
 142   def __init__(self, data):
 143     """Creates a new QMP message based on the passed data.
 144
 145     """
 146     if not isinstance(data, dict):
 147       raise TypeError("QmpMessage must be initialized with a dict")
 148
 149     self.data = data
 150
 151   def __getitem__(self, field_name):
 152     """Get the value of the required field if present, or None.
 153
 154     Overrides the [] operator to provide access to the message data,
 155     returning None if the required item is not in the message
 156     @return: the value of the field_name field, or None if field_name
 157              is not contained in the message
 158
 159     """
 160     return self.data.get(field_name, None)
 161
 162   def __setitem__(self, field_name, field_value):
 163     """Set the value of the required field_name to field_value.
 164
 165     """
 166     self.data[field_name] = field_value
 167
 168   @staticmethod
 169   def BuildFromJsonString(json_string):
 170     """Build a QmpMessage from a JSON encoded string.
 171
 172     @type json_string: str
 173     @param json_string: JSON string representing the message
 174     @rtype: L{QmpMessage}
 175     @return: a L{QmpMessage} built from json_string
 176
 177     """
 178     # Parse the string
 179     data = serializer.LoadJson(json_string)
 180     return QmpMessage(data)
 181
 182   def __str__(self):
 183     # The protocol expects the JSON object to be sent as a single line.
 184     return serializer.DumpJson(self.data)
 185
 186   def __eq__(self, other):
 187     # When comparing two QmpMessages, we are interested in comparing
 188     # their internal representation of the message data
 189     return self.data == other.data
 190
 191
 192 class QmpConnection:
 193   """Connection to the QEMU Monitor using the QEMU Monitor Protocol (QMP).
 194
 195   """
 196   _FIRST_MESSAGE_KEY = "QMP"
 197   _EVENT_KEY = "event"
 198   _ERROR_KEY = "error"
 199   _RETURN_KEY = RETURN_KEY = "return"
 200   _ACTUAL_KEY = ACTUAL_KEY = "actual"
 201   _ERROR_CLASS_KEY = "class"
 202   _ERROR_DATA_KEY = "data"
 203   _ERROR_DESC_KEY = "desc"
 204   _EXECUTE_KEY = "execute"
 205   _ARGUMENTS_KEY = "arguments"
 206   _CAPABILITIES_COMMAND = "qmp_capabilities"
 207   _MESSAGE_END_TOKEN = "\r\n"
 208   _SOCKET_TIMEOUT = 5
 209
 210   def __init__(self, monitor_filename):
 211     """Instantiates the QmpConnection object.
 212
 213     @type monitor_filename: string
 214     @param monitor_filename: the filename of the UNIX raw socket on which the
 215                              QMP monitor is listening
 216
 217     """
 218     self.monitor_filename = monitor_filename
 219     self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 220     # We want to fail if the server doesn't send a complete message
 221     # in a reasonable amount of time
 222     self.sock.settimeout(self._SOCKET_TIMEOUT)
 223     self._connected = False
 224     self._buf = ""
 225
 226   def _check_socket(self):
 227     sock_stat = None
 228     try:
 229       sock_stat = os.stat(self.monitor_filename)
 230     except EnvironmentError, err:
 231       if err.errno == errno.ENOENT:
 232         raise errors.HypervisorError("No qmp socket found")
 233       else:
 234         raise errors.HypervisorError("Error checking qmp socket: %s",
 235                                      utils.ErrnoOrStr(err))
 236     if not stat.S_ISSOCK(sock_stat.st_mode):
 237       raise errors.HypervisorError("Qmp socket is not a socket")
 238
 239   def _check_connection(self):
 240     """Make sure that the connection is established.
 241
 242     """
 243     if not self._connected:
 244       raise errors.ProgrammerError("To use a QmpConnection you need to first"
 245                                    " invoke connect() on it")
 246
 247   def connect(self):
 248     """Connects to the QMP monitor.
 249
 250     Connects to the UNIX socket and makes sure that we can actually send and
 251     receive data to the kvm instance via QMP.
 252
 253     @raise errors.HypervisorError: when there are communication errors
 254     @raise errors.ProgrammerError: when there are data serialization errors
 255
 256     """
 257     if self._connected:
 258       raise errors.ProgrammerError("Cannot connect twice")
 259
 260     self._check_socket()
 261
 262     # Check file existance/stuff
 263     try:
 264       self.sock.connect(self.monitor_filename)
 265     except EnvironmentError:
 266       raise errors.HypervisorError("Can't connect to qmp socket")
 267     self._connected = True
 268
 269     # Check if we receive a correct greeting message from the server
 270     # (As per the QEMU Protocol Specification 0.1 - section 2.2)
 271     greeting = self._Recv()
 272     if not greeting[self._FIRST_MESSAGE_KEY]:
 273       self._connected = False
 274       raise errors.HypervisorError("kvm: qmp communication error (wrong"
 275                                    " server greeting")
 276
 277     # Let's put the monitor in command mode using the qmp_capabilities
 278     # command, or else no command will be executable.
 279     # (As per the QEMU Protocol Specification 0.1 - section 4)
 280     self.Execute(self._CAPABILITIES_COMMAND)
 281
 282   def _ParseMessage(self, buf):
 283     """Extract and parse a QMP message from the given buffer.
 284
 285     Seeks for a QMP message in the given buf. If found, it parses it and
 286     returns it together with the rest of the characters in the buf.
 287     If no message is found, returns None and the whole buffer.
 288
 289     @raise errors.ProgrammerError: when there are data serialization errors
 290
 291     """
 292     message = None
 293     # Check if we got the message end token (CRLF, as per the QEMU Protocol
 294     # Specification 0.1 - Section 2.1.1)
 295     pos = buf.find(self._MESSAGE_END_TOKEN)
 296     if pos >= 0:
 297       try:
 298         message = QmpMessage.BuildFromJsonString(buf[:pos + 1])
 299       except Exception, err:
 300         raise errors.ProgrammerError("QMP data serialization error: %s" % err)
 301       buf = buf[pos + 1:]
 302
 303     return (message, buf)
 304
 305   def _Recv(self):
 306     """Receives a message from QMP and decodes the received JSON object.
 307
 308     @rtype: QmpMessage
 309     @return: the received message
 310     @raise errors.HypervisorError: when there are communication errors
 311     @raise errors.ProgrammerError: when there are data serialization errors
 312
 313     """
 314     self._check_connection()
 315
 316     # Check if there is already a message in the buffer
 317     (message, self._buf) = self._ParseMessage(self._buf)
 318     if message:
 319       return message
 320
 321     recv_buffer = StringIO.StringIO(self._buf)
 322     recv_buffer.seek(len(self._buf))
 323     try:
 324       while True:
 325         data = self.sock.recv(4096)
 326         if not data:
 327           break
 328         recv_buffer.write(data)
 329
 330         (message, self._buf) = self._ParseMessage(recv_buffer.getvalue())
 331         if message:
 332           return message
 333
 334     except socket.timeout, err:
 335       raise errors.HypervisorError("Timeout while receiving a QMP message: "
 336                                    "%s" % (err))
 337     except socket.error, err:
 338       raise errors.HypervisorError("Unable to receive data from KVM using the"
 339                                    " QMP protocol: %s" % err)
 340
 341   def _Send(self, message):
 342     """Encodes and sends a message to KVM using QMP.
 343
 344     @type message: QmpMessage
 345     @param message: message to send to KVM
 346     @raise errors.HypervisorError: when there are communication errors
 347     @raise errors.ProgrammerError: when there are data serialization errors
 348
 349     """
 350     self._check_connection()
 351     try:
 352       message_str = str(message)
 353     except Exception, err:
 354       raise errors.ProgrammerError("QMP data deserialization error: %s" % err)
 355
 356     try:
 357       self.sock.sendall(message_str)
 358     except socket.timeout, err:
 359       raise errors.HypervisorError("Timeout while sending a QMP message: "
 360                                    "%s (%s)" % (err.string, err.errno))
 361     except socket.error, err:
 362       raise errors.HypervisorError("Unable to send data from KVM using the"
 363                                    " QMP protocol: %s" % err)
 364
 365   def Execute(self, command, arguments=None):
 366     """Executes a QMP command and returns the response of the server.
 367
 368     @type command: str
 369     @param command: the command to execute
 370     @type arguments: dict
 371     @param arguments: dictionary of arguments to be passed to the command
 372     @rtype: dict
 373     @return: dictionary representing the received JSON object
 374     @raise errors.HypervisorError: when there are communication errors
 375     @raise errors.ProgrammerError: when there are data serialization errors
 376
 377     """
 378     self._check_connection()
 379     message = QmpMessage({self._EXECUTE_KEY: command})
 380     if arguments:
 381       message[self._ARGUMENTS_KEY] = arguments
 382     self._Send(message)
 383
 384     # Events can occur between the sending of the command and the reception
 385     # of the response, so we need to filter out messages with the event key.
 386     while True:
 387       response = self._Recv()
 388       err = response[self._ERROR_KEY]
 389       if err:
 390         raise errors.HypervisorError("kvm: error executing the %s"
 391                                      " command: %s (%s, %s):" %
 392                                      (command,
 393                                       err[self._ERROR_DESC_KEY],
 394                                       err[self._ERROR_CLASS_KEY],
 395                                       err[self._ERROR_DATA_KEY]))
 396
 397       elif not response[self._EVENT_KEY]:
 398         return response
 399
 400
 401 class KVMHypervisor(hv_base.BaseHypervisor):
 402   """KVM hypervisor interface
 403
 404   """
 405   CAN_MIGRATE = True
 406
 407   _ROOT_DIR = constants.RUN_DIR + "/kvm-hypervisor"
 408   _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids
 409   _UIDS_DIR = _ROOT_DIR + "/uid" # contains instances reserved uids
 410   _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets
 411   _CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data
 412   _NICS_DIR = _ROOT_DIR + "/nic" # contains instances nic <-> tap associations
 413   _KEYMAP_DIR = _ROOT_DIR + "/keymap" # contains instances keymaps
 414   # KVM instances with chroot enabled are started in empty chroot directories.
 415   _CHROOT_DIR = _ROOT_DIR + "/chroot" # for empty chroot directories
 416   # After an instance is stopped, its chroot directory is removed.
 417   # If the chroot directory is not empty, it can't be removed.
 418   # A non-empty chroot directory indicates a possible security incident.
 419   # To support forensics, the non-empty chroot directory is quarantined in
 420   # a separate directory, called 'chroot-quarantine'.
 421   _CHROOT_QUARANTINE_DIR = _ROOT_DIR + "/chroot-quarantine"
 422   _DIRS = [_ROOT_DIR, _PIDS_DIR, _UIDS_DIR, _CTRL_DIR, _CONF_DIR, _NICS_DIR,
 423            _CHROOT_DIR, _CHROOT_QUARANTINE_DIR, _KEYMAP_DIR]
 424
 425   PARAMETERS = {
 426     constants.HV_KERNEL_PATH: hv_base.OPT_FILE_CHECK,
 427     constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
 428     constants.HV_ROOT_PATH: hv_base.NO_CHECK,
 429     constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
 430     constants.HV_ACPI: hv_base.NO_CHECK,
 431     constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,
 432     constants.HV_VNC_BIND_ADDRESS:
 433       (False, lambda x: (netutils.IP4Address.IsValid(x) or
 434                          utils.IsNormAbsPath(x)),
 435        "the VNC bind address must be either a valid IP address or an absolute"
 436        " pathname", None, None),
 437     constants.HV_VNC_TLS: hv_base.NO_CHECK,
 438     constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,
 439     constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK,
 440     constants.HV_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
 441     constants.HV_KVM_SPICE_BIND: hv_base.NO_CHECK, # will be checked later
 442     constants.HV_KVM_SPICE_IP_VERSION:
 443       (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or
 444                          x in constants.VALID_IP_VERSIONS),
 445        "the SPICE IP version should be 4 or 6",
 446        None, None),
 447     constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
 448     constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:
 449       hv_base.ParamInSet(
 450         False, constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),
 451     constants.HV_KVM_SPICE_JPEG_IMG_COMPR:
 452       hv_base.ParamInSet(
 453         False, constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 454     constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:
 455       hv_base.ParamInSet(
 456         False, constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 457     constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:
 458       hv_base.ParamInSet(
 459         False, constants.HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS),
 460     constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,
 461     constants.HV_KVM_SPICE_USE_TLS: hv_base.NO_CHECK,
 462     constants.HV_KVM_SPICE_TLS_CIPHERS: hv_base.NO_CHECK,
 463     constants.HV_KVM_SPICE_USE_VDAGENT: hv_base.NO_CHECK,
 464     constants.HV_KVM_FLOPPY_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 465     constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 466     constants.HV_KVM_CDROM2_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 467     constants.HV_BOOT_ORDER:
 468       hv_base.ParamInSet(True, constants.HT_KVM_VALID_BO_TYPES),
 469     constants.HV_NIC_TYPE:
 470       hv_base.ParamInSet(True, constants.HT_KVM_VALID_NIC_TYPES),
 471     constants.HV_DISK_TYPE:
 472       hv_base.ParamInSet(True, constants.HT_KVM_VALID_DISK_TYPES),
 473     constants.HV_KVM_CDROM_DISK_TYPE:
 474       hv_base.ParamInSet(False, constants.HT_KVM_VALID_DISK_TYPES),
 475     constants.HV_USB_MOUSE:
 476       hv_base.ParamInSet(False, constants.HT_KVM_VALID_MOUSE_TYPES),
 477     constants.HV_KEYMAP: hv_base.NO_CHECK,
 478     constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
 479     constants.HV_MIGRATION_BANDWIDTH: hv_base.NO_CHECK,
 480     constants.HV_MIGRATION_DOWNTIME: hv_base.NO_CHECK,
 481     constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
 482     constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
 483     constants.HV_DISK_CACHE:
 484       hv_base.ParamInSet(True, constants.HT_VALID_CACHE_TYPES),
 485     constants.HV_SECURITY_MODEL:
 486       hv_base.ParamInSet(True, constants.HT_KVM_VALID_SM_TYPES),
 487     constants.HV_SECURITY_DOMAIN: hv_base.NO_CHECK,
 488     constants.HV_KVM_FLAG:
 489       hv_base.ParamInSet(False, constants.HT_KVM_FLAG_VALUES),
 490     constants.HV_VHOST_NET: hv_base.NO_CHECK,
 491     constants.HV_KVM_USE_CHROOT: hv_base.NO_CHECK,
 492     constants.HV_MEM_PATH: hv_base.OPT_DIR_CHECK,
 493     constants.HV_REBOOT_BEHAVIOR:
 494       hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
 495     constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,
 496     constants.HV_CPU_TYPE: hv_base.NO_CHECK
 497     }
 498
 499   _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",
 500                                     re.M | re.I)
 501   _MIGRATION_PROGRESS_RE = \
 502     re.compile(r"\s*transferred\s+ram:\s+(?P<transferred>\d+)\s+kbytes\s*\n"
 503                r"\s*remaining\s+ram:\s+(?P<remaining>\d+)\s+kbytes\s*\n"
 504                r"\s*total\s+ram:\s+(?P<total>\d+)\s+kbytes\s*\n", re.I)
 505
 506   _MIGRATION_INFO_MAX_BAD_ANSWERS = 5
 507   _MIGRATION_INFO_RETRY_DELAY = 2
 508
 509   _VERSION_RE = re.compile(r"\b(\d+)\.(\d+)(\.(\d+))?\b")
 510
 511   _CPU_INFO_RE = re.compile(r"cpu\s+\#(\d+).*thread_id\s*=\s*(\d+)", re.I)
 512   _CPU_INFO_CMD = "info cpus"
 513   _CONT_CMD = "cont"
 514
 515   ANCILLARY_FILES = [
 516     _KVM_NETWORK_SCRIPT,
 517     ]
 518   ANCILLARY_FILES_OPT = [
 519     _KVM_NETWORK_SCRIPT,
 520     ]
 521
 522   def __init__(self):
 523     hv_base.BaseHypervisor.__init__(self)
 524     # Let's make sure the directories we need exist, even if the RUN_DIR lives
 525     # in a tmpfs filesystem or has been otherwise wiped out.
 526     dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]
 527     utils.EnsureDirs(dirs)
 528
 529   @classmethod
 530   def _InstancePidFile(cls, instance_name):
 531     """Returns the instance pidfile.
 532
 533     """
 534     return utils.PathJoin(cls._PIDS_DIR, instance_name)
 535
 536   @classmethod
 537   def _InstanceUidFile(cls, instance_name):
 538     """Returns the instance uidfile.
 539
 540     """
 541     return utils.PathJoin(cls._UIDS_DIR, instance_name)
 542
 543   @classmethod
 544   def _InstancePidInfo(cls, pid):
 545     """Check pid file for instance information.
 546
 547     Check that a pid file is associated with an instance, and retrieve
 548     information from its command line.
 549
 550     @type pid: string or int
 551     @param pid: process id of the instance to check
 552     @rtype: tuple
 553     @return: (instance_name, memory, vcpus)
 554     @raise errors.HypervisorError: when an instance cannot be found
 555
 556     """
 557     alive = utils.IsProcessAlive(pid)
 558     if not alive:
 559       raise errors.HypervisorError("Cannot get info for pid %s" % pid)
 560
 561     cmdline_file = utils.PathJoin("/proc", str(pid), "cmdline")
 562     try:
 563       cmdline = utils.ReadFile(cmdline_file)
 564     except EnvironmentError, err:
 565       raise errors.HypervisorError("Can't open cmdline file for pid %s: %s" %
 566                                    (pid, err))
 567
 568     instance = None
 569     memory = 0
 570     vcpus = 0
 571
 572     arg_list = cmdline.split("\x00")
 573     while arg_list:
 574       arg = arg_list.pop(0)
 575       if arg == "-name":
 576         instance = arg_list.pop(0)
 577       elif arg == "-m":
 578         memory = int(arg_list.pop(0))
 579       elif arg == "-smp":
 580         vcpus = int(arg_list.pop(0))
 581
 582     if instance is None:
 583       raise errors.HypervisorError("Pid %s doesn't contain a ganeti kvm"
 584                                    " instance" % pid)
 585
 586     return (instance, memory, vcpus)
 587
 588   def _InstancePidAlive(self, instance_name):
 589     """Returns the instance pidfile, pid, and liveness.
 590
 591     @type instance_name: string
 592     @param instance_name: instance name
 593     @rtype: tuple
 594     @return: (pid file name, pid, liveness)
 595
 596     """
 597     pidfile = self._InstancePidFile(instance_name)
 598     pid = utils.ReadPidFile(pidfile)
 599
 600     alive = False
 601     try:
 602       cmd_instance = self._InstancePidInfo(pid)[0]
 603       alive = (cmd_instance == instance_name)
 604     except errors.HypervisorError:
 605       pass
 606
 607     return (pidfile, pid, alive)
 608
 609   def _CheckDown(self, instance_name):
 610     """Raises an error unless the given instance is down.
 611
 612     """
 613     alive = self._InstancePidAlive(instance_name)[2]
 614     if alive:
 615       raise errors.HypervisorError("Failed to start instance %s: %s" %
 616                                    (instance_name, "already running"))
 617
 618   @classmethod
 619   def _InstanceMonitor(cls, instance_name):
 620     """Returns the instance monitor socket name
 621
 622     """
 623     return utils.PathJoin(cls._CTRL_DIR, "%s.monitor" % instance_name)
 624
 625   @classmethod
 626   def _InstanceSerial(cls, instance_name):
 627     """Returns the instance serial socket name
 628
 629     """
 630     return utils.PathJoin(cls._CTRL_DIR, "%s.serial" % instance_name)
 631
 632   @classmethod
 633   def _InstanceQmpMonitor(cls, instance_name):
 634     """Returns the instance serial QMP socket name
 635
 636     """
 637     return utils.PathJoin(cls._CTRL_DIR, "%s.qmp" % instance_name)
 638
 639   @staticmethod
 640   def _SocatUnixConsoleParams():
 641     """Returns the correct parameters for socat
 642
 643     If we have a new-enough socat we can use raw mode with an escape character.
 644
 645     """
 646     if constants.SOCAT_USE_ESCAPE:
 647       return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE
 648     else:
 649       return "echo=0,icanon=0"
 650
 651   @classmethod
 652   def _InstanceKVMRuntime(cls, instance_name):
 653     """Returns the instance KVM runtime filename
 654
 655     """
 656     return utils.PathJoin(cls._CONF_DIR, "%s.runtime" % instance_name)
 657
 658   @classmethod
 659   def _InstanceChrootDir(cls, instance_name):
 660     """Returns the name of the KVM chroot dir of the instance
 661
 662     """
 663     return utils.PathJoin(cls._CHROOT_DIR, instance_name)
 664
 665   @classmethod
 666   def _InstanceNICDir(cls, instance_name):
 667     """Returns the name of the directory holding the tap device files for a
 668     given instance.
 669
 670     """
 671     return utils.PathJoin(cls._NICS_DIR, instance_name)
 672
 673   @classmethod
 674   def _InstanceNICFile(cls, instance_name, seq):
 675     """Returns the name of the file containing the tap device for a given NIC
 676
 677     """
 678     return utils.PathJoin(cls._InstanceNICDir(instance_name), str(seq))
 679
 680   @classmethod
 681   def _InstanceKeymapFile(cls, instance_name):
 682     """Returns the name of the file containing the keymap for a given instance
 683
 684     """
 685     return utils.PathJoin(cls._KEYMAP_DIR, instance_name)
 686
 687   @classmethod
 688   def _TryReadUidFile(cls, uid_file):
 689     """Try to read a uid file
 690
 691     """
 692     if os.path.exists(uid_file):
 693       try:
 694         uid = int(utils.ReadOneLineFile(uid_file))
 695         return uid
 696       except EnvironmentError:
 697         logging.warning("Can't read uid file", exc_info=True)
 698       except (TypeError, ValueError):
 699         logging.warning("Can't parse uid file contents", exc_info=True)
 700     return None
 701
 702   @classmethod
 703   def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):
 704     """Removes an instance's rutime sockets/files/dirs.
 705
 706     """
 707     utils.RemoveFile(pidfile)
 708     utils.RemoveFile(cls._InstanceMonitor(instance_name))
 709     utils.RemoveFile(cls._InstanceSerial(instance_name))
 710     utils.RemoveFile(cls._InstanceQmpMonitor(instance_name))
 711     utils.RemoveFile(cls._InstanceKVMRuntime(instance_name))
 712     utils.RemoveFile(cls._InstanceKeymapFile(instance_name))
 713     uid_file = cls._InstanceUidFile(instance_name)
 714     uid = cls._TryReadUidFile(uid_file)
 715     utils.RemoveFile(uid_file)
 716     if uid is not None:
 717       uidpool.ReleaseUid(uid)
 718     try:
 719       shutil.rmtree(cls._InstanceNICDir(instance_name))
 720     except OSError, err:
 721       if err.errno != errno.ENOENT:
 722         raise
 723     try:
 724       chroot_dir = cls._InstanceChrootDir(instance_name)
 725       utils.RemoveDir(chroot_dir)
 726     except OSError, err:
 727       if err.errno == errno.ENOTEMPTY:
 728         # The chroot directory is expected to be empty, but it isn't.
 729         new_chroot_dir = tempfile.mkdtemp(dir=cls._CHROOT_QUARANTINE_DIR,
 730                                           prefix="%s-%s-" %
 731                                           (instance_name,
 732                                            utils.TimestampForFilename()))
 733         logging.warning("The chroot directory of instance %s can not be"
 734                         " removed as it is not empty. Moving it to the"
 735                         " quarantine instead. Please investigate the"
 736                         " contents (%s) and clean up manually",
 737                         instance_name, new_chroot_dir)
 738         utils.RenameFile(chroot_dir, new_chroot_dir)
 739       else:
 740         raise
 741
 742   @staticmethod
 743   def _ConfigureNIC(instance, seq, nic, tap):
 744     """Run the network configuration script for a specified NIC
 745
 746     @param instance: instance we're acting on
 747     @type instance: instance object
 748     @param seq: nic sequence number
 749     @type seq: int
 750     @param nic: nic we're acting on
 751     @type nic: nic object
 752     @param tap: the host's tap interface this NIC corresponds to
 753     @type tap: str
 754
 755     """
 756     if instance.tags:
 757       tags = " ".join(instance.tags)
 758     else:
 759       tags = ""
 760
 761     env = {
 762       "PATH": "%s:/sbin:/usr/sbin" % os.environ["PATH"],
 763       "INSTANCE": instance.name,
 764       "MAC": nic.mac,
 765       "MODE": nic.nicparams[constants.NIC_MODE],
 766       "INTERFACE": tap,
 767       "INTERFACE_INDEX": str(seq),
 768       "TAGS": tags,
 769     }
 770
 771     if nic.ip:
 772       env["IP"] = nic.ip
 773
 774     if nic.nicparams[constants.NIC_LINK]:
 775       env["LINK"] = nic.nicparams[constants.NIC_LINK]
 776
 777     if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
 778       env["BRIDGE"] = nic.nicparams[constants.NIC_LINK]
 779
 780     result = utils.RunCmd([constants.KVM_IFUP, tap], env=env)
 781     if result.failed:
 782       raise errors.HypervisorError("Failed to configure interface %s: %s."
 783                                    " Network configuration script output: %s" %
 784                                    (tap, result.fail_reason, result.output))
 785
 786   @staticmethod
 787   def _VerifyAffinityPackage():
 788     if affinity is None:
 789       raise errors.HypervisorError("affinity Python package not"
 790                                    " found; cannot use CPU pinning under KVM")
 791
 792   @staticmethod
 793   def _BuildAffinityCpuMask(cpu_list):
 794     """Create a CPU mask suitable for sched_setaffinity from a list of
 795     CPUs.
 796
 797     See man taskset for more info on sched_setaffinity masks.
 798     For example: [ 0, 2, 5, 6 ] will return 101 (0x65, 0..01100101).
 799
 800     @type cpu_list: list of int
 801     @param cpu_list: list of physical CPU numbers to map to vCPUs in order
 802     @rtype: int
 803     @return: a bit mask of CPU affinities
 804
 805     """
 806     if cpu_list == constants.CPU_PINNING_OFF:
 807       return constants.CPU_PINNING_ALL_KVM
 808     else:
 809       return sum(2 ** cpu for cpu in cpu_list)
 810
 811   @classmethod
 812   def _AssignCpuAffinity(cls, cpu_mask, process_id, thread_dict):
 813     """Change CPU affinity for running VM according to given CPU mask.
 814
 815     @param cpu_mask: CPU mask as given by the user. e.g. "0-2,4:all:1,3"
 816     @type cpu_mask: string
 817     @param process_id: process ID of KVM process. Used to pin entire VM
 818                        to physical CPUs.
 819     @type process_id: int
 820     @param thread_dict: map of virtual CPUs to KVM thread IDs
 821     @type thread_dict: dict int:int
 822
 823     """
 824     # Convert the string CPU mask to a list of list of int's
 825     cpu_list = utils.ParseMultiCpuMask(cpu_mask)
 826
 827     if len(cpu_list) == 1:
 828       all_cpu_mapping = cpu_list[0]
 829       if all_cpu_mapping == constants.CPU_PINNING_OFF:
 830         # If CPU pinning has 1 entry that's "all", then do nothing
 831         pass
 832       else:
 833         # If CPU pinning has one non-all entry, map the entire VM to
 834         # one set of physical CPUs
 835         cls._VerifyAffinityPackage()
 836         affinity.set_process_affinity_mask(
 837           process_id, cls._BuildAffinityCpuMask(all_cpu_mapping))
 838     else:
 839       # The number of vCPUs mapped should match the number of vCPUs
 840       # reported by KVM. This was already verified earlier, so
 841       # here only as a sanity check.
 842       assert len(thread_dict) == len(cpu_list)
 843       cls._VerifyAffinityPackage()
 844
 845       # For each vCPU, map it to the proper list of physical CPUs
 846       for vcpu, i in zip(cpu_list, range(len(cpu_list))):
 847         affinity.set_process_affinity_mask(thread_dict[i],
 848                                            cls._BuildAffinityCpuMask(vcpu))
 849
 850   def _GetVcpuThreadIds(self, instance_name):
 851     """Get a mapping of vCPU no. to thread IDs for the instance
 852
 853     @type instance_name: string
 854     @param instance_name: instance in question
 855     @rtype: dictionary of int:int
 856     @return: a dictionary mapping vCPU numbers to thread IDs
 857
 858     """
 859     result = {}
 860     output = self._CallMonitorCommand(instance_name, self._CPU_INFO_CMD)
 861     for line in output.stdout.splitlines():
 862       match = self._CPU_INFO_RE.search(line)
 863       if not match:
 864         continue
 865       grp = map(int, match.groups())
 866       result[grp[0]] = grp[1]
 867
 868     return result
 869
 870   def _ExecuteCpuAffinity(self, instance_name, cpu_mask):
 871     """Complete CPU pinning.
 872
 873     @type instance_name: string
 874     @param instance_name: name of instance
 875     @type cpu_mask: string
 876     @param cpu_mask: CPU pinning mask as entered by user
 877
 878     """
 879     # Get KVM process ID, to be used if need to pin entire VM
 880     _, pid, _ = self._InstancePidAlive(instance_name)
 881     # Get vCPU thread IDs, to be used if need to pin vCPUs separately
 882     thread_dict = self._GetVcpuThreadIds(instance_name)
 883     # Run CPU pinning, based on configured mask
 884     self._AssignCpuAffinity(cpu_mask, pid, thread_dict)
 885
 886   def ListInstances(self):
 887     """Get the list of running instances.
 888
 889     We can do this by listing our live instances directory and
 890     checking whether the associated kvm process is still alive.
 891
 892     """
 893     result = []
 894     for name in os.listdir(self._PIDS_DIR):
 895       if self._InstancePidAlive(name)[2]:
 896         result.append(name)
 897     return result
 898
 899   def GetInstanceInfo(self, instance_name):
 900     """Get instance properties.
 901
 902     @type instance_name: string
 903     @param instance_name: the instance name
 904     @rtype: tuple of strings
 905     @return: (name, id, memory, vcpus, stat, times)
 906
 907     """
 908     _, pid, alive = self._InstancePidAlive(instance_name)
 909     if not alive:
 910       return None
 911
 912     _, memory, vcpus = self._InstancePidInfo(pid)
 913     istat = "---b-"
 914     times = "0"
 915
 916     try:
 917       qmp = QmpConnection(self._InstanceQmpMonitor(instance_name))
 918       qmp.connect()
 919       vcpus = len(qmp.Execute("query-cpus")[qmp.RETURN_KEY])
 920       # Will fail if ballooning is not enabled, but we can then just resort to
 921       # the value above.
 922       mem_bytes = qmp.Execute("query-balloon")[qmp.RETURN_KEY][qmp.ACTUAL_KEY]
 923       memory = mem_bytes / 1048576
 924     except errors.HypervisorError:
 925       pass
 926
 927     return (instance_name, pid, memory, vcpus, istat, times)
 928
 929   def GetAllInstancesInfo(self):
 930     """Get properties of all instances.
 931
 932     @return: list of tuples (name, id, memory, vcpus, stat, times)
 933
 934     """
 935     data = []
 936     for name in os.listdir(self._PIDS_DIR):
 937       try:
 938         info = self.GetInstanceInfo(name)
 939       except errors.HypervisorError:
 940         # Ignore exceptions due to instances being shut down
 941         continue
 942       if info:
 943         data.append(info)
 944     return data
 945
 946   def _GenerateKVMRuntime(self, instance, block_devices, startup_paused):
 947     """Generate KVM information to start an instance.
 948
 949     @attention: this function must not have any side-effects; for
 950         example, it must not write to the filesystem, or read values
 951         from the current system the are expected to differ between
 952         nodes, since it is only run once at instance startup;
 953         actions/kvm arguments that can vary between systems should be
 954         done in L{_ExecuteKVMRuntime}
 955
 956     """
 957     # pylint: disable=R0914,R0915
 958     _, v_major, v_min, _ = self._GetKVMVersion()
 959
 960     pidfile = self._InstancePidFile(instance.name)
 961     kvm = constants.KVM_PATH
 962     kvm_cmd = [kvm]
 963     # used just by the vnc server, if enabled
 964     kvm_cmd.extend(["-name", instance.name])
 965     kvm_cmd.extend(["-m", instance.beparams[constants.BE_MAXMEM]])
 966     kvm_cmd.extend(["-smp", instance.beparams[constants.BE_VCPUS]])
 967     kvm_cmd.extend(["-pidfile", pidfile])
 968     kvm_cmd.extend(["-balloon", "virtio"])
 969     kvm_cmd.extend(["-daemonize"])
 970     if not instance.hvparams[constants.HV_ACPI]:
 971       kvm_cmd.extend(["-no-acpi"])
 972     if instance.hvparams[constants.HV_REBOOT_BEHAVIOR] == \
 973         constants.INSTANCE_REBOOT_EXIT:
 974       kvm_cmd.extend(["-no-reboot"])
 975
 976     hvp = instance.hvparams
 977     kernel_path = hvp[constants.HV_KERNEL_PATH]
 978     if kernel_path:
 979       boot_disk = boot_cdrom = boot_floppy = boot_network = False
 980     else:
 981       boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
 982       boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM
 983       boot_floppy = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_FLOPPY
 984       boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
 985
 986     self.ValidateParameters(hvp)
 987
 988     if startup_paused:
 989       kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
 990
 991     if hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED:
 992       kvm_cmd.extend(["-enable-kvm"])
 993     elif hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED:
 994       kvm_cmd.extend(["-disable-kvm"])
 995
 996     if boot_network:
 997       kvm_cmd.extend(["-boot", "n"])
 998
 999     # whether this is an older KVM version that uses the boot=on flag
1000     # on devices
1001     needs_boot_flag = (v_major, v_min) < (0, 14)
1002
1003     disk_type = hvp[constants.HV_DISK_TYPE]
1004     if disk_type == constants.HT_DISK_PARAVIRTUAL:
1005       if_val = ",if=virtio"
1006     else:
1007       if_val = ",if=%s" % disk_type
1008     # Cache mode
1009     disk_cache = hvp[constants.HV_DISK_CACHE]
1010     if instance.disk_template in constants.DTS_EXT_MIRROR:
1011       if disk_cache != "none":
1012         # TODO: make this a hard error, instead of a silent overwrite
1013         logging.warning("KVM: overriding disk_cache setting '%s' with 'none'"
1014                         " to prevent shared storage corruption on migration",
1015                         disk_cache)
1016       cache_val = ",cache=none"
1017     elif disk_cache != constants.HT_CACHE_DEFAULT:
1018       cache_val = ",cache=%s" % disk_cache
1019     else:
1020       cache_val = ""
1021     for cfdev, dev_path in block_devices:
1022       if cfdev.mode != constants.DISK_RDWR:
1023         raise errors.HypervisorError("Instance has read-only disks which"
1024                                      " are not supported by KVM")
1025       # TODO: handle FD_LOOP and FD_BLKTAP (?)
1026       boot_val = ""
1027       if boot_disk:
1028         kvm_cmd.extend(["-boot", "c"])
1029         boot_disk = False
1030         if needs_boot_flag and disk_type != constants.HT_DISK_IDE:
1031           boot_val = ",boot=on"
1032
1033       drive_val = "file=%s,format=raw%s%s%s" % (dev_path, if_val, boot_val,
1034                                                 cache_val)
1035       kvm_cmd.extend(["-drive", drive_val])
1036
1037     #Now we can specify a different device type for CDROM devices.
1038     cdrom_disk_type = hvp[constants.HV_KVM_CDROM_DISK_TYPE]
1039     if not cdrom_disk_type:
1040       cdrom_disk_type = disk_type
1041
1042     iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
1043     if iso_image:
1044       options = ",format=raw,media=cdrom"
1045       # set cdrom 'if' type
1046       if boot_cdrom:
1047         actual_cdrom_type = constants.HT_DISK_IDE
1048       elif cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1049         actual_cdrom_type = "virtio"
1050       else:
1051         actual_cdrom_type = cdrom_disk_type
1052       if_val = ",if=%s" % actual_cdrom_type
1053       # set boot flag, if needed
1054       boot_val = ""
1055       if boot_cdrom:
1056         kvm_cmd.extend(["-boot", "d"])
1057         if needs_boot_flag:
1058           boot_val = ",boot=on"
1059       # and finally build the entire '-drive' value
1060       drive_val = "file=%s%s%s%s" % (iso_image, options, if_val, boot_val)
1061       kvm_cmd.extend(["-drive", drive_val])
1062
1063     iso_image2 = hvp[constants.HV_KVM_CDROM2_IMAGE_PATH]
1064     if iso_image2:
1065       options = ",format=raw,media=cdrom"
1066       if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1067         if_val = ",if=virtio"
1068       else:
1069         if_val = ",if=%s" % cdrom_disk_type
1070       drive_val = "file=%s%s%s" % (iso_image2, options, if_val)
1071       kvm_cmd.extend(["-drive", drive_val])
1072
1073     floppy_image = hvp[constants.HV_KVM_FLOPPY_IMAGE_PATH]
1074     if floppy_image:
1075       options = ",format=raw,media=disk"
1076       if boot_floppy:
1077         kvm_cmd.extend(["-boot", "a"])
1078         options = "%s,boot=on" % options
1079       if_val = ",if=floppy"
1080       options = "%s%s" % (options, if_val)
1081       drive_val = "file=%s%s" % (floppy_image, options)
1082       kvm_cmd.extend(["-drive", drive_val])
1083
1084     if kernel_path:
1085       kvm_cmd.extend(["-kernel", kernel_path])
1086       initrd_path = hvp[constants.HV_INITRD_PATH]
1087       if initrd_path:
1088         kvm_cmd.extend(["-initrd", initrd_path])
1089       root_append = ["root=%s" % hvp[constants.HV_ROOT_PATH],
1090                      hvp[constants.HV_KERNEL_ARGS]]
1091       if hvp[constants.HV_SERIAL_CONSOLE]:
1092         root_append.append("console=ttyS0,38400")
1093       kvm_cmd.extend(["-append", " ".join(root_append)])
1094
1095     mem_path = hvp[constants.HV_MEM_PATH]
1096     if mem_path:
1097       kvm_cmd.extend(["-mem-path", mem_path, "-mem-prealloc"])
1098
1099     monitor_dev = ("unix:%s,server,nowait" %
1100                    self._InstanceMonitor(instance.name))
1101     kvm_cmd.extend(["-monitor", monitor_dev])
1102     if hvp[constants.HV_SERIAL_CONSOLE]:
1103       serial_dev = ("unix:%s,server,nowait" %
1104                     self._InstanceSerial(instance.name))
1105       kvm_cmd.extend(["-serial", serial_dev])
1106     else:
1107       kvm_cmd.extend(["-serial", "none"])
1108
1109     mouse_type = hvp[constants.HV_USB_MOUSE]
1110     vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
1111     spice_bind = hvp[constants.HV_KVM_SPICE_BIND]
1112     spice_ip_version = None
1113
1114     if mouse_type:
1115       kvm_cmd.extend(["-usb"])
1116       kvm_cmd.extend(["-usbdevice", mouse_type])
1117     elif vnc_bind_address:
1118       kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
1119
1120     if vnc_bind_address:
1121       if netutils.IP4Address.IsValid(vnc_bind_address):
1122         if instance.network_port > constants.VNC_BASE_PORT:
1123           display = instance.network_port - constants.VNC_BASE_PORT
1124           if vnc_bind_address == constants.IP4_ADDRESS_ANY:
1125             vnc_arg = ":%d" % (display)
1126           else:
1127             vnc_arg = "%s:%d" % (vnc_bind_address, display)
1128         else:
1129           logging.error("Network port is not a valid VNC display (%d < %d)."
1130                         " Not starting VNC", instance.network_port,
1131                         constants.VNC_BASE_PORT)
1132           vnc_arg = "none"
1133
1134         # Only allow tls and other option when not binding to a file, for now.
1135         # kvm/qemu gets confused otherwise about the filename to use.
1136         vnc_append = ""
1137         if hvp[constants.HV_VNC_TLS]:
1138           vnc_append = "%s,tls" % vnc_append
1139           if hvp[constants.HV_VNC_X509_VERIFY]:
1140             vnc_append = "%s,x509verify=%s" % (vnc_append,
1141                                                hvp[constants.HV_VNC_X509])
1142           elif hvp[constants.HV_VNC_X509]:
1143             vnc_append = "%s,x509=%s" % (vnc_append,
1144                                          hvp[constants.HV_VNC_X509])
1145         if hvp[constants.HV_VNC_PASSWORD_FILE]:
1146           vnc_append = "%s,password" % vnc_append
1147
1148         vnc_arg = "%s%s" % (vnc_arg, vnc_append)
1149
1150       else:
1151         vnc_arg = "unix:%s/%s.vnc" % (vnc_bind_address, instance.name)
1152
1153       kvm_cmd.extend(["-vnc", vnc_arg])
1154     elif spice_bind:
1155       # FIXME: this is wrong here; the iface ip address differs
1156       # between systems, so it should be done in _ExecuteKVMRuntime
1157       if netutils.IsValidInterface(spice_bind):
1158         # The user specified a network interface, we have to figure out the IP
1159         # address.
1160         addresses = netutils.GetInterfaceIpAddresses(spice_bind)
1161         spice_ip_version = hvp[constants.HV_KVM_SPICE_IP_VERSION]
1162
1163         # if the user specified an IP version and the interface does not
1164         # have that kind of IP addresses, throw an exception
1165         if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
1166           if not addresses[spice_ip_version]:
1167             raise errors.HypervisorError("spice: unable to get an IPv%s address"
1168                                          " for %s" % (spice_ip_version,
1169                                                       spice_bind))
1170
1171         # the user did not specify an IP version, we have to figure it out
1172         elif (addresses[constants.IP4_VERSION] and
1173               addresses[constants.IP6_VERSION]):
1174           # we have both ipv4 and ipv6, let's use the cluster default IP
1175           # version
1176           cluster_family = ssconf.SimpleStore().GetPrimaryIPFamily()
1177           spice_ip_version = \
1178             netutils.IPAddress.GetVersionFromAddressFamily(cluster_family)
1179         elif addresses[constants.IP4_VERSION]:
1180           spice_ip_version = constants.IP4_VERSION
1181         elif addresses[constants.IP6_VERSION]:
1182           spice_ip_version = constants.IP6_VERSION
1183         else:
1184           raise errors.HypervisorError("spice: unable to get an IP address"
1185                                        " for %s" % (spice_bind))
1186
1187         spice_address = addresses[spice_ip_version][0]
1188
1189       else:
1190         # spice_bind is known to be a valid IP address, because
1191         # ValidateParameters checked it.
1192         spice_address = spice_bind
1193
1194       spice_arg = "addr=%s" % spice_address
1195       if hvp[constants.HV_KVM_SPICE_USE_TLS]:
1196         spice_arg = ("%s,tls-port=%s,x509-cacert-file=%s" %
1197                      (spice_arg, instance.network_port,
1198                       constants.SPICE_CACERT_FILE))
1199         spice_arg = ("%s,x509-key-file=%s,x509-cert-file=%s" %
1200                      (spice_arg, constants.SPICE_CERT_FILE,
1201                       constants.SPICE_CERT_FILE))
1202         tls_ciphers = hvp[constants.HV_KVM_SPICE_TLS_CIPHERS]
1203         if tls_ciphers:
1204           spice_arg = "%s,tls-ciphers=%s" % (spice_arg, tls_ciphers)
1205       else:
1206         spice_arg = "%s,port=%s" % (spice_arg, instance.network_port)
1207
1208       if not hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]:
1209         spice_arg = "%s,disable-ticketing" % spice_arg
1210
1211       if spice_ip_version:
1212         spice_arg = "%s,ipv%s" % (spice_arg, spice_ip_version)
1213
1214       # Image compression options
1215       img_lossless = hvp[constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR]
1216       img_jpeg = hvp[constants.HV_KVM_SPICE_JPEG_IMG_COMPR]
1217       img_zlib_glz = hvp[constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR]
1218       if img_lossless:
1219         spice_arg = "%s,image-compression=%s" % (spice_arg, img_lossless)
1220       if img_jpeg:
1221         spice_arg = "%s,jpeg-wan-compression=%s" % (spice_arg, img_jpeg)
1222       if img_zlib_glz:
1223         spice_arg = "%s,zlib-glz-wan-compression=%s" % (spice_arg, img_zlib_glz)
1224
1225       # Video stream detection
1226       video_streaming = hvp[constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION]
1227       if video_streaming:
1228         spice_arg = "%s,streaming-video=%s" % (spice_arg, video_streaming)
1229
1230       # Audio compression, by default in qemu-kvm it is on
1231       if not hvp[constants.HV_KVM_SPICE_AUDIO_COMPR]:
1232         spice_arg = "%s,playback-compression=off" % spice_arg
1233       if not hvp[constants.HV_KVM_SPICE_USE_VDAGENT]:
1234         spice_arg = "%s,agent-mouse=off" % spice_arg
1235       else:
1236         # Enable the spice agent communication channel between the host and the
1237         # agent.
1238         kvm_cmd.extend(["-device", "virtio-serial-pci"])
1239         kvm_cmd.extend(["-device", "virtserialport,chardev=spicechannel0,"
1240                                                    "name=com.redhat.spice.0"])
1241         kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"])
1242
1243       logging.info("KVM: SPICE will listen on port %s", instance.network_port)
1244       kvm_cmd.extend(["-spice", spice_arg])
1245
1246       # Tell kvm to use the paravirtualized graphic card, optimized for SPICE
1247       kvm_cmd.extend(["-vga", "qxl"])
1248
1249     else:
1250       kvm_cmd.extend(["-nographic"])
1251
1252     if hvp[constants.HV_USE_LOCALTIME]:
1253       kvm_cmd.extend(["-localtime"])
1254
1255     if hvp[constants.HV_KVM_USE_CHROOT]:
1256       kvm_cmd.extend(["-chroot", self._InstanceChrootDir(instance.name)])
1257
1258     # Add qemu-KVM -cpu param
1259     if hvp[constants.HV_CPU_TYPE]:
1260       kvm_cmd.extend(["-cpu", hvp[constants.HV_CPU_TYPE]])
1261
1262     # Save the current instance nics, but defer their expansion as parameters,
1263     # as we'll need to generate executable temp files for them.
1264     kvm_nics = instance.nics
1265     hvparams = hvp
1266
1267     return (kvm_cmd, kvm_nics, hvparams)
1268
1269   def _WriteKVMRuntime(self, instance_name, data):
1270     """Write an instance's KVM runtime
1271
1272     """
1273     try:
1274       utils.WriteFile(self._InstanceKVMRuntime(instance_name),
1275                       data=data)
1276     except EnvironmentError, err:
1277       raise errors.HypervisorError("Failed to save KVM runtime file: %s" % err)
1278
1279   def _ReadKVMRuntime(self, instance_name):
1280     """Read an instance's KVM runtime
1281
1282     """
1283     try:
1284       file_content = utils.ReadFile(self._InstanceKVMRuntime(instance_name))
1285     except EnvironmentError, err:
1286       raise errors.HypervisorError("Failed to load KVM runtime file: %s" % err)
1287     return file_content
1288
1289   def _SaveKVMRuntime(self, instance, kvm_runtime):
1290     """Save an instance's KVM runtime
1291
1292     """
1293     kvm_cmd, kvm_nics, hvparams = kvm_runtime
1294     serialized_nics = [nic.ToDict() for nic in kvm_nics]
1295     serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams))
1296     self._WriteKVMRuntime(instance.name, serialized_form)
1297
1298   def _LoadKVMRuntime(self, instance, serialized_runtime=None):
1299     """Load an instance's KVM runtime
1300
1301     """
1302     if not serialized_runtime:
1303       serialized_runtime = self._ReadKVMRuntime(instance.name)
1304     loaded_runtime = serializer.Load(serialized_runtime)
1305     kvm_cmd, serialized_nics, hvparams = loaded_runtime
1306     kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics]
1307     return (kvm_cmd, kvm_nics, hvparams)
1308
1309   def _RunKVMCmd(self, name, kvm_cmd, tap_fds=None):
1310     """Run the KVM cmd and check for errors
1311
1312     @type name: string
1313     @param name: instance name
1314     @type kvm_cmd: list of strings
1315     @param kvm_cmd: runcmd input for kvm
1316     @type tap_fds: list of int
1317     @param tap_fds: fds of tap devices opened by Ganeti
1318
1319     """
1320     try:
1321       result = utils.RunCmd(kvm_cmd, noclose_fds=tap_fds)
1322     finally:
1323       for fd in tap_fds:
1324         utils_wrapper.CloseFdNoError(fd)
1325
1326     if result.failed:
1327       raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
1328                                    (name, result.fail_reason, result.output))
1329     if not self._InstancePidAlive(name)[2]:
1330       raise errors.HypervisorError("Failed to start instance %s" % name)
1331
1332   def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None):
1333     """Execute a KVM cmd, after completing it with some last minute data.
1334
1335     @type incoming: tuple of strings
1336     @param incoming: (target_host_ip, port)
1337
1338     """
1339     # Small _ExecuteKVMRuntime hv parameters programming howto:
1340     #  - conf_hvp contains the parameters as configured on ganeti. they might
1341     #    have changed since the instance started; only use them if the change
1342     #    won't affect the inside of the instance (which hasn't been rebooted).
1343     #  - up_hvp contains the parameters as they were when the instance was
1344     #    started, plus any new parameter which has been added between ganeti
1345     #    versions: it is paramount that those default to a value which won't
1346     #    affect the inside of the instance as well.
1347     conf_hvp = instance.hvparams
1348     name = instance.name
1349     self._CheckDown(name)
1350
1351     temp_files = []
1352
1353     kvm_cmd, kvm_nics, up_hvp = kvm_runtime
1354     up_hvp = objects.FillDict(conf_hvp, up_hvp)
1355
1356     _, v_major, v_min, _ = self._GetKVMVersion()
1357
1358     # We know it's safe to run as a different user upon migration, so we'll use
1359     # the latest conf, from conf_hvp.
1360     security_model = conf_hvp[constants.HV_SECURITY_MODEL]
1361     if security_model == constants.HT_SM_USER:
1362       kvm_cmd.extend(["-runas", conf_hvp[constants.HV_SECURITY_DOMAIN]])
1363
1364     keymap = conf_hvp[constants.HV_KEYMAP]
1365     if keymap:
1366       keymap_path = self._InstanceKeymapFile(name)
1367       # If a keymap file is specified, KVM won't use its internal defaults. By
1368       # first including the "en-us" layout, an error on loading the actual
1369       # layout (e.g. because it can't be found) won't lead to a non-functional
1370       # keyboard. A keyboard with incorrect keys is still better than none.
1371       utils.WriteFile(keymap_path, data="include en-us\ninclude %s\n" % keymap)
1372       kvm_cmd.extend(["-k", keymap_path])
1373
1374     # We have reasons to believe changing something like the nic driver/type
1375     # upon migration won't exactly fly with the instance kernel, so for nic
1376     # related parameters we'll use up_hvp
1377     tapfds = []
1378     taps = []
1379     if not kvm_nics:
1380       kvm_cmd.extend(["-net", "none"])
1381     else:
1382       vnet_hdr = False
1383       tap_extra = ""
1384       nic_type = up_hvp[constants.HV_NIC_TYPE]
1385       if nic_type == constants.HT_NIC_PARAVIRTUAL:
1386         # From version 0.12.0, kvm uses a new sintax for network configuration.
1387         if (v_major, v_min) >= (0, 12):
1388           nic_model = "virtio-net-pci"
1389           vnet_hdr = True
1390         else:
1391           nic_model = "virtio"
1392
1393         if up_hvp[constants.HV_VHOST_NET]:
1394           # vhost_net is only available from version 0.13.0 or newer
1395           if (v_major, v_min) >= (0, 13):
1396             tap_extra = ",vhost=on"
1397           else:
1398             raise errors.HypervisorError("vhost_net is configured"
1399                                          " but it is not available")
1400       else:
1401         nic_model = nic_type
1402
1403       for nic_seq, nic in enumerate(kvm_nics):
1404         tapname, tapfd = _OpenTap(vnet_hdr)
1405         tapfds.append(tapfd)
1406         taps.append(tapname)
1407         if (v_major, v_min) >= (0, 12):
1408           nic_val = "%s,mac=%s,netdev=netdev%s" % (nic_model, nic.mac, nic_seq)
1409           tap_val = "type=tap,id=netdev%s,fd=%d%s" % (nic_seq, tapfd, tap_extra)
1410           kvm_cmd.extend(["-netdev", tap_val, "-device", nic_val])
1411         else:
1412           nic_val = "nic,vlan=%s,macaddr=%s,model=%s" % (nic_seq,
1413                                                          nic.mac, nic_model)
1414           tap_val = "tap,vlan=%s,fd=%d" % (nic_seq, tapfd)
1415           kvm_cmd.extend(["-net", tap_val, "-net", nic_val])
1416
1417     if incoming:
1418       target, port = incoming
1419       kvm_cmd.extend(["-incoming", "tcp:%s:%s" % (target, port)])
1420
1421     # Changing the vnc password doesn't bother the guest that much. At most it
1422     # will surprise people who connect to it. Whether positively or negatively
1423     # it's debatable.
1424     vnc_pwd_file = conf_hvp[constants.HV_VNC_PASSWORD_FILE]
1425     vnc_pwd = None
1426     if vnc_pwd_file:
1427       try:
1428         vnc_pwd = utils.ReadOneLineFile(vnc_pwd_file, strict=True)
1429       except EnvironmentError, err:
1430         raise errors.HypervisorError("Failed to open VNC password file %s: %s"
1431                                      % (vnc_pwd_file, err))
1432
1433     if conf_hvp[constants.HV_KVM_USE_CHROOT]:
1434       utils.EnsureDirs([(self._InstanceChrootDir(name),
1435                          constants.SECURE_DIR_MODE)])
1436
1437     # Automatically enable QMP if version is >= 0.14
1438     if (v_major, v_min) >= (0, 14):
1439       logging.debug("Enabling QMP")
1440       kvm_cmd.extend(["-qmp", "unix:%s,server,nowait" %
1441                       self._InstanceQmpMonitor(instance.name)])
1442
1443     # Configure the network now for starting instances and bridged interfaces,
1444     # during FinalizeMigration for incoming instances' routed interfaces
1445     for nic_seq, nic in enumerate(kvm_nics):
1446       if (incoming and
1447           nic.nicparams[constants.NIC_MODE] != constants.NIC_MODE_BRIDGED):
1448         continue
1449       self._ConfigureNIC(instance, nic_seq, nic, taps[nic_seq])
1450
1451     # CPU affinity requires kvm to start paused, so we set this flag if the
1452     # instance is not already paused and if we are not going to accept a
1453     # migrating instance. In the latter case, pausing is not needed.
1454     start_kvm_paused = not (_KVM_START_PAUSED_FLAG in kvm_cmd) and not incoming
1455     if start_kvm_paused:
1456       kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
1457
1458     # Note: CPU pinning is using up_hvp since changes take effect
1459     # during instance startup anyway, and to avoid problems when soft
1460     # rebooting the instance.
1461     cpu_pinning = False
1462     if up_hvp.get(constants.HV_CPU_MASK, None):
1463       cpu_pinning = True
1464
1465     if security_model == constants.HT_SM_POOL:
1466       ss = ssconf.SimpleStore()
1467       uid_pool = uidpool.ParseUidPool(ss.GetUidPool(), separator="\n")
1468       all_uids = set(uidpool.ExpandUidPool(uid_pool))
1469       uid = uidpool.RequestUnusedUid(all_uids)
1470       try:
1471         username = pwd.getpwuid(uid.GetUid()).pw_name
1472         kvm_cmd.extend(["-runas", username])
1473         self._RunKVMCmd(name, kvm_cmd, tapfds)
1474       except:
1475         uidpool.ReleaseUid(uid)
1476         raise
1477       else:
1478         uid.Unlock()
1479         utils.WriteFile(self._InstanceUidFile(name), data=uid.AsStr())
1480     else:
1481       self._RunKVMCmd(name, kvm_cmd, tapfds)
1482
1483     utils.EnsureDirs([(self._InstanceNICDir(instance.name),
1484                      constants.RUN_DIRS_MODE)])
1485     for nic_seq, tap in enumerate(taps):
1486       utils.WriteFile(self._InstanceNICFile(instance.name, nic_seq),
1487                       data=tap)
1488
1489     if vnc_pwd:
1490       change_cmd = "change vnc password %s" % vnc_pwd
1491       self._CallMonitorCommand(instance.name, change_cmd)
1492
1493     # Setting SPICE password. We are not vulnerable to malicious passwordless
1494     # connection attempts because SPICE by default does not allow connections
1495     # if neither a password nor the "disable_ticketing" options are specified.
1496     # As soon as we send the password via QMP, that password is a valid ticket
1497     # for connection.
1498     spice_password_file = conf_hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]
1499     if spice_password_file:
1500       spice_pwd = ""
1501       try:
1502         spice_pwd = utils.ReadOneLineFile(spice_password_file, strict=True)
1503       except EnvironmentError, err:
1504         raise errors.HypervisorError("Failed to open SPICE password file %s: %s"
1505                                      % (spice_password_file, err))
1506
1507       qmp = QmpConnection(self._InstanceQmpMonitor(instance.name))
1508       qmp.connect()
1509       arguments = {
1510           "protocol": "spice",
1511           "password": spice_pwd,
1512       }
1513       qmp.Execute("set_password", arguments)
1514
1515     for filename in temp_files:
1516       utils.RemoveFile(filename)
1517
1518     # If requested, set CPU affinity and resume instance execution
1519     if cpu_pinning:
1520       self._ExecuteCpuAffinity(instance.name, up_hvp[constants.HV_CPU_MASK])
1521
1522     start_memory = self._InstanceStartupMemory(instance)
1523     if start_memory < instance.beparams[constants.BE_MAXMEM]:
1524       self.BalloonInstanceMemory(instance, start_memory)
1525
1526     if start_kvm_paused:
1527       # To control CPU pinning, ballooning, and vnc/spice passwords
1528       # the VM was started in a frozen state. If freezing was not
1529       # explicitly requested resume the vm status.
1530       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1531
1532   def StartInstance(self, instance, block_devices, startup_paused):
1533     """Start an instance.
1534
1535     """
1536     self._CheckDown(instance.name)
1537     kvm_runtime = self._GenerateKVMRuntime(instance, block_devices,
1538                                            startup_paused)
1539     self._SaveKVMRuntime(instance, kvm_runtime)
1540     self._ExecuteKVMRuntime(instance, kvm_runtime)
1541
1542   def _CallMonitorCommand(self, instance_name, command):
1543     """Invoke a command on the instance monitor.
1544
1545     """
1546     socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" %
1547              (utils.ShellQuote(command),
1548               constants.SOCAT_PATH,
1549               utils.ShellQuote(self._InstanceMonitor(instance_name))))
1550     result = utils.RunCmd(socat)
1551     if result.failed:
1552       msg = ("Failed to send command '%s' to instance %s."
1553              " output: %s, error: %s, fail_reason: %s" %
1554              (command, instance_name,
1555               result.stdout, result.stderr, result.fail_reason))
1556       raise errors.HypervisorError(msg)
1557
1558     return result
1559
1560   @classmethod
1561   def _ParseKVMVersion(cls, text):
1562     """Parse the KVM version from the --help output.
1563
1564     @type text: string
1565     @param text: output of kvm --help
1566     @return: (version, v_maj, v_min, v_rev)
1567     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1568
1569     """
1570     match = cls._VERSION_RE.search(text.splitlines()[0])
1571     if not match:
1572       raise errors.HypervisorError("Unable to get KVM version")
1573
1574     v_all = match.group(0)
1575     v_maj = int(match.group(1))
1576     v_min = int(match.group(2))
1577     if match.group(4):
1578       v_rev = int(match.group(4))
1579     else:
1580       v_rev = 0
1581     return (v_all, v_maj, v_min, v_rev)
1582
1583   @classmethod
1584   def _GetKVMVersion(cls):
1585     """Return the installed KVM version.
1586
1587     @return: (version, v_maj, v_min, v_rev)
1588     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1589
1590     """
1591     result = utils.RunCmd([constants.KVM_PATH, "--help"])
1592     if result.failed:
1593       raise errors.HypervisorError("Unable to get KVM version")
1594     return cls._ParseKVMVersion(result.output)
1595
1596   def StopInstance(self, instance, force=False, retry=False, name=None):
1597     """Stop an instance.
1598
1599     """
1600     if name is not None and not force:
1601       raise errors.HypervisorError("Cannot shutdown cleanly by name only")
1602     if name is None:
1603       name = instance.name
1604       acpi = instance.hvparams[constants.HV_ACPI]
1605     else:
1606       acpi = False
1607     _, pid, alive = self._InstancePidAlive(name)
1608     if pid > 0 and alive:
1609       if force or not acpi:
1610         utils.KillProcess(pid)
1611       else:
1612         self._CallMonitorCommand(name, "system_powerdown")
1613
1614   def CleanupInstance(self, instance_name):
1615     """Cleanup after a stopped instance
1616
1617     """
1618     pidfile, pid, alive = self._InstancePidAlive(instance_name)
1619     if pid > 0 and alive:
1620       raise errors.HypervisorError("Cannot cleanup a live instance")
1621     self._RemoveInstanceRuntimeFiles(pidfile, instance_name)
1622
1623   def RebootInstance(self, instance):
1624     """Reboot an instance.
1625
1626     """
1627     # For some reason if we do a 'send-key ctrl-alt-delete' to the control
1628     # socket the instance will stop, but now power up again. So we'll resort
1629     # to shutdown and restart.
1630     _, _, alive = self._InstancePidAlive(instance.name)
1631     if not alive:
1632       raise errors.HypervisorError("Failed to reboot instance %s:"
1633                                    " not running" % instance.name)
1634     # StopInstance will delete the saved KVM runtime so:
1635     # ...first load it...
1636     kvm_runtime = self._LoadKVMRuntime(instance)
1637     # ...now we can safely call StopInstance...
1638     if not self.StopInstance(instance):
1639       self.StopInstance(instance, force=True)
1640     # ...and finally we can save it again, and execute it...
1641     self._SaveKVMRuntime(instance, kvm_runtime)
1642     self._ExecuteKVMRuntime(instance, kvm_runtime)
1643
1644   def MigrationInfo(self, instance):
1645     """Get instance information to perform a migration.
1646
1647     @type instance: L{objects.Instance}
1648     @param instance: instance to be migrated
1649     @rtype: string
1650     @return: content of the KVM runtime file
1651
1652     """
1653     return self._ReadKVMRuntime(instance.name)
1654
1655   def AcceptInstance(self, instance, info, target):
1656     """Prepare to accept an instance.
1657
1658     @type instance: L{objects.Instance}
1659     @param instance: instance to be accepted
1660     @type info: string
1661     @param info: content of the KVM runtime file on the source node
1662     @type target: string
1663     @param target: target host (usually ip), on this node
1664
1665     """
1666     kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1667     incoming_address = (target, instance.hvparams[constants.HV_MIGRATION_PORT])
1668     self._ExecuteKVMRuntime(instance, kvm_runtime, incoming=incoming_address)
1669
1670   def FinalizeMigrationDst(self, instance, info, success):
1671     """Finalize the instance migration on the target node.
1672
1673     Stop the incoming mode KVM.
1674
1675     @type instance: L{objects.Instance}
1676     @param instance: instance whose migration is being finalized
1677
1678     """
1679     if success:
1680       kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1681       kvm_nics = kvm_runtime[1]
1682
1683       for nic_seq, nic in enumerate(kvm_nics):
1684         if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
1685           # Bridged interfaces have already been configured
1686           continue
1687         try:
1688           tap = utils.ReadFile(self._InstanceNICFile(instance.name, nic_seq))
1689         except EnvironmentError, err:
1690           logging.warning("Failed to find host interface for %s NIC #%d: %s",
1691                           instance.name, nic_seq, str(err))
1692           continue
1693         try:
1694           self._ConfigureNIC(instance, nic_seq, nic, tap)
1695         except errors.HypervisorError, err:
1696           logging.warning(str(err))
1697
1698       self._WriteKVMRuntime(instance.name, info)
1699     else:
1700       self.StopInstance(instance, force=True)
1701
1702   def MigrateInstance(self, instance, target, live):
1703     """Migrate an instance to a target node.
1704
1705     The migration will not be attempted if the instance is not
1706     currently running.
1707
1708     @type instance: L{objects.Instance}
1709     @param instance: the instance to be migrated
1710     @type target: string
1711     @param target: ip address of the target node
1712     @type live: boolean
1713     @param live: perform a live migration
1714
1715     """
1716     instance_name = instance.name
1717     port = instance.hvparams[constants.HV_MIGRATION_PORT]
1718     _, _, alive = self._InstancePidAlive(instance_name)
1719     if not alive:
1720       raise errors.HypervisorError("Instance not running, cannot migrate")
1721
1722     if not live:
1723       self._CallMonitorCommand(instance_name, "stop")
1724
1725     migrate_command = ("migrate_set_speed %dm" %
1726                        instance.hvparams[constants.HV_MIGRATION_BANDWIDTH])
1727     self._CallMonitorCommand(instance_name, migrate_command)
1728
1729     migrate_command = ("migrate_set_downtime %dms" %
1730                        instance.hvparams[constants.HV_MIGRATION_DOWNTIME])
1731     self._CallMonitorCommand(instance_name, migrate_command)
1732
1733     migrate_command = "migrate -d tcp:%s:%s" % (target, port)
1734     self._CallMonitorCommand(instance_name, migrate_command)
1735
1736   def FinalizeMigrationSource(self, instance, success, live):
1737     """Finalize the instance migration on the source node.
1738
1739     @type instance: L{objects.Instance}
1740     @param instance: the instance that was migrated
1741     @type success: bool
1742     @param success: whether the migration succeeded or not
1743     @type live: bool
1744     @param live: whether the user requested a live migration or not
1745
1746     """
1747     if success:
1748       pidfile, pid, _ = self._InstancePidAlive(instance.name)
1749       utils.KillProcess(pid)
1750       self._RemoveInstanceRuntimeFiles(pidfile, instance.name)
1751     elif live:
1752       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1753
1754   def GetMigrationStatus(self, instance):
1755     """Get the migration status
1756
1757     @type instance: L{objects.Instance}
1758     @param instance: the instance that is being migrated
1759     @rtype: L{objects.MigrationStatus}
1760     @return: the status of the current migration (one of
1761              L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
1762              progress info that can be retrieved from the hypervisor
1763
1764     """
1765     info_command = "info migrate"
1766     for _ in range(self._MIGRATION_INFO_MAX_BAD_ANSWERS):
1767       result = self._CallMonitorCommand(instance.name, info_command)
1768       match = self._MIGRATION_STATUS_RE.search(result.stdout)
1769       if not match:
1770         if not result.stdout:
1771           logging.info("KVM: empty 'info migrate' result")
1772         else:
1773           logging.warning("KVM: unknown 'info migrate' result: %s",
1774                           result.stdout)
1775       else:
1776         status = match.group(1)
1777         if status in constants.HV_KVM_MIGRATION_VALID_STATUSES:
1778           migration_status = objects.MigrationStatus(status=status)
1779           match = self._MIGRATION_PROGRESS_RE.search(result.stdout)
1780           if match:
1781             migration_status.transferred_ram = match.group("transferred")
1782             migration_status.total_ram = match.group("total")
1783
1784           return migration_status
1785
1786         logging.warning("KVM: unknown migration status '%s'", status)
1787
1788       time.sleep(self._MIGRATION_INFO_RETRY_DELAY)
1789
1790     return objects.MigrationStatus(status=constants.HV_MIGRATION_FAILED,
1791                                    info="Too many 'info migrate'"
1792                                    " broken answers")
1793
1794   def BalloonInstanceMemory(self, instance, mem):
1795     """Balloon an instance memory to a certain value.
1796
1797     @type instance: L{objects.Instance}
1798     @param instance: instance to be accepted
1799     @type mem: int
1800     @param mem: actual memory size to use for instance runtime
1801
1802     """
1803     self._CallMonitorCommand(instance.name, "balloon %d" % mem)
1804
1805   def GetNodeInfo(self):
1806     """Return information about the node.
1807
1808     @return: a dict with the following keys (values in MiB):
1809           - memory_total: the total memory size on the node
1810           - memory_free: the available memory on the node for instances
1811           - memory_dom0: the memory used by the node itself, if available
1812           - hv_version: the hypervisor version in the form (major, minor,
1813                         revision)
1814
1815     """
1816     result = self.GetLinuxNodeInfo()
1817     _, v_major, v_min, v_rev = self._GetKVMVersion()
1818     result[constants.HV_NODEINFO_KEY_VERSION] = (v_major, v_min, v_rev)
1819     return result
1820
1821   @classmethod
1822   def GetInstanceConsole(cls, instance, hvparams, beparams):
1823     """Return a command for connecting to the console of an instance.
1824
1825     """
1826     if hvparams[constants.HV_SERIAL_CONSOLE]:
1827       cmd = [constants.KVM_CONSOLE_WRAPPER,
1828              constants.SOCAT_PATH, utils.ShellQuote(instance.name),
1829              utils.ShellQuote(cls._InstanceMonitor(instance.name)),
1830              "STDIO,%s" % cls._SocatUnixConsoleParams(),
1831              "UNIX-CONNECT:%s" % cls._InstanceSerial(instance.name)]
1832       return objects.InstanceConsole(instance=instance.name,
1833                                      kind=constants.CONS_SSH,
1834                                      host=instance.primary_node,
1835                                      user=constants.GANETI_RUNAS,
1836                                      command=cmd)
1837
1838     vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
1839     if vnc_bind_address and instance.network_port > constants.VNC_BASE_PORT:
1840       display = instance.network_port - constants.VNC_BASE_PORT
1841       return objects.InstanceConsole(instance=instance.name,
1842                                      kind=constants.CONS_VNC,
1843                                      host=vnc_bind_address,
1844                                      port=instance.network_port,
1845                                      display=display)
1846
1847     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1848     if spice_bind:
1849       return objects.InstanceConsole(instance=instance.name,
1850                                      kind=constants.CONS_SPICE,
1851                                      host=spice_bind,
1852                                      port=instance.network_port)
1853
1854     return objects.InstanceConsole(instance=instance.name,
1855                                    kind=constants.CONS_MESSAGE,
1856                                    message=("No serial shell for instance %s" %
1857                                             instance.name))
1858
1859   def Verify(self):
1860     """Verify the hypervisor.
1861
1862     Check that the binary exists.
1863
1864     """
1865     if not os.path.exists(constants.KVM_PATH):
1866       return "The kvm binary ('%s') does not exist." % constants.KVM_PATH
1867     if not os.path.exists(constants.SOCAT_PATH):
1868       return "The socat binary ('%s') does not exist." % constants.SOCAT_PATH
1869
1870   @classmethod
1871   def CheckParameterSyntax(cls, hvparams):
1872     """Check the given parameters for validity.
1873
1874     @type hvparams:  dict
1875     @param hvparams: dictionary with parameter names/value
1876     @raise errors.HypervisorError: when a parameter is not valid
1877
1878     """
1879     super(KVMHypervisor, cls).CheckParameterSyntax(hvparams)
1880
1881     kernel_path = hvparams[constants.HV_KERNEL_PATH]
1882     if kernel_path:
1883       if not hvparams[constants.HV_ROOT_PATH]:
1884         raise errors.HypervisorError("Need a root partition for the instance,"
1885                                      " if a kernel is defined")
1886
1887     if (hvparams[constants.HV_VNC_X509_VERIFY] and
1888         not hvparams[constants.HV_VNC_X509]):
1889       raise errors.HypervisorError("%s must be defined, if %s is" %
1890                                    (constants.HV_VNC_X509,
1891                                     constants.HV_VNC_X509_VERIFY))
1892
1893     boot_order = hvparams[constants.HV_BOOT_ORDER]
1894     if (boot_order == constants.HT_BO_CDROM and
1895         not hvparams[constants.HV_CDROM_IMAGE_PATH]):
1896       raise errors.HypervisorError("Cannot boot from cdrom without an"
1897                                    " ISO path")
1898
1899     security_model = hvparams[constants.HV_SECURITY_MODEL]
1900     if security_model == constants.HT_SM_USER:
1901       if not hvparams[constants.HV_SECURITY_DOMAIN]:
1902         raise errors.HypervisorError("A security domain (user to run kvm as)"
1903                                      " must be specified")
1904     elif (security_model == constants.HT_SM_NONE or
1905           security_model == constants.HT_SM_POOL):
1906       if hvparams[constants.HV_SECURITY_DOMAIN]:
1907         raise errors.HypervisorError("Cannot have a security domain when the"
1908                                      " security model is 'none' or 'pool'")
1909
1910     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1911     spice_ip_version = hvparams[constants.HV_KVM_SPICE_IP_VERSION]
1912     if spice_bind:
1913       if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
1914         # if an IP version is specified, the spice_bind parameter must be an
1915         # IP of that family
1916         if (netutils.IP4Address.IsValid(spice_bind) and
1917             spice_ip_version != constants.IP4_VERSION):
1918           raise errors.HypervisorError("spice: got an IPv4 address (%s), but"
1919                                        " the specified IP version is %s" %
1920                                        (spice_bind, spice_ip_version))
1921
1922         if (netutils.IP6Address.IsValid(spice_bind) and
1923             spice_ip_version != constants.IP6_VERSION):
1924           raise errors.HypervisorError("spice: got an IPv6 address (%s), but"
1925                                        " the specified IP version is %s" %
1926                                        (spice_bind, spice_ip_version))
1927     else:
1928       # All the other SPICE parameters depend on spice_bind being set. Raise an
1929       # error if any of them is set without it.
1930       spice_additional_params = frozenset([
1931         constants.HV_KVM_SPICE_IP_VERSION,
1932         constants.HV_KVM_SPICE_PASSWORD_FILE,
1933         constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR,
1934         constants.HV_KVM_SPICE_JPEG_IMG_COMPR,
1935         constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR,
1936         constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION,
1937         constants.HV_KVM_SPICE_USE_TLS,
1938         ])
1939       for param in spice_additional_params:
1940         if hvparams[param]:
1941           raise errors.HypervisorError("spice: %s requires %s to be set" %
1942                                        (param, constants.HV_KVM_SPICE_BIND))
1943
1944   @classmethod
1945   def ValidateParameters(cls, hvparams):
1946     """Check the given parameters for validity.
1947
1948     @type hvparams:  dict
1949     @param hvparams: dictionary with parameter names/value
1950     @raise errors.HypervisorError: when a parameter is not valid
1951
1952     """
1953     super(KVMHypervisor, cls).ValidateParameters(hvparams)
1954
1955     security_model = hvparams[constants.HV_SECURITY_MODEL]
1956     if security_model == constants.HT_SM_USER:
1957       username = hvparams[constants.HV_SECURITY_DOMAIN]
1958       try:
1959         pwd.getpwnam(username)
1960       except KeyError:
1961         raise errors.HypervisorError("Unknown security domain user %s"
1962                                      % username)
1963
1964     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1965     if spice_bind:
1966       # only one of VNC and SPICE can be used currently.
1967       if hvparams[constants.HV_VNC_BIND_ADDRESS]:
1968         raise errors.HypervisorError("both SPICE and VNC are configured, but"
1969                                      " only one of them can be used at a"
1970                                      " given time.")
1971
1972       # KVM version should be >= 0.14.0
1973       _, v_major, v_min, _ = cls._GetKVMVersion()
1974       if (v_major, v_min) < (0, 14):
1975         raise errors.HypervisorError("spice is configured, but it is not"
1976                                      " available in versions of KVM < 0.14")
1977
1978       # if spice_bind is not an IP address, it must be a valid interface
1979       bound_to_addr = (netutils.IP4Address.IsValid(spice_bind)
1980                        or netutils.IP6Address.IsValid(spice_bind))
1981       if not bound_to_addr and not netutils.IsValidInterface(spice_bind):
1982         raise errors.HypervisorError("spice: the %s parameter must be either"
1983                                      " a valid IP address or interface name" %
1984                                      constants.HV_KVM_SPICE_BIND)
1985
1986   @classmethod
1987   def PowercycleNode(cls):
1988     """KVM powercycle, just a wrapper over Linux powercycle.
1989
1990     """
1991     cls.LinuxPowercycle()