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_GANETI_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(False,
 450         constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),
 451     constants.HV_KVM_SPICE_JPEG_IMG_COMPR:
 452       hv_base.ParamInSet(False,
 453         constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 454     constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:
 455       hv_base.ParamInSet(False,
 456         constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 457     constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:
 458       hv_base.ParamInSet(False,
 459         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     }
 497
 498   _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",
 499                                     re.M | re.I)
 500   _MIGRATION_PROGRESS_RE = \
 501     re.compile(r"\s*transferred\s+ram:\s+(?P<transferred>\d+)\s+kbytes\s*\n"
 502                r"\s*remaining\s+ram:\s+(?P<remaining>\d+)\s+kbytes\s*\n"
 503                r"\s*total\s+ram:\s+(?P<total>\d+)\s+kbytes\s*\n", re.I)
 504
 505   _MIGRATION_INFO_MAX_BAD_ANSWERS = 5
 506   _MIGRATION_INFO_RETRY_DELAY = 2
 507
 508   _VERSION_RE = re.compile(r"\b(\d+)\.(\d+)(\.(\d+))?\b")
 509
 510   _CPU_INFO_RE = re.compile(r"cpu\s+\#(\d+).*thread_id\s*=\s*(\d+)", re.I)
 511   _CPU_INFO_CMD = "info cpus"
 512   _CONT_CMD = "cont"
 513
 514   ANCILLARY_FILES = [
 515     _KVM_NETWORK_SCRIPT,
 516     ]
 517   ANCILLARY_FILES_OPT = [
 518     _KVM_NETWORK_SCRIPT,
 519     ]
 520
 521   def __init__(self):
 522     hv_base.BaseHypervisor.__init__(self)
 523     # Let's make sure the directories we need exist, even if the RUN_DIR lives
 524     # in a tmpfs filesystem or has been otherwise wiped out.
 525     dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]
 526     utils.EnsureDirs(dirs)
 527
 528   @classmethod
 529   def _InstancePidFile(cls, instance_name):
 530     """Returns the instance pidfile.
 531
 532     """
 533     return utils.PathJoin(cls._PIDS_DIR, instance_name)
 534
 535   @classmethod
 536   def _InstanceUidFile(cls, instance_name):
 537     """Returns the instance uidfile.
 538
 539     """
 540     return utils.PathJoin(cls._UIDS_DIR, instance_name)
 541
 542   @classmethod
 543   def _InstancePidInfo(cls, pid):
 544     """Check pid file for instance information.
 545
 546     Check that a pid file is associated with an instance, and retrieve
 547     information from its command line.
 548
 549     @type pid: string or int
 550     @param pid: process id of the instance to check
 551     @rtype: tuple
 552     @return: (instance_name, memory, vcpus)
 553     @raise errors.HypervisorError: when an instance cannot be found
 554
 555     """
 556     alive = utils.IsProcessAlive(pid)
 557     if not alive:
 558       raise errors.HypervisorError("Cannot get info for pid %s" % pid)
 559
 560     cmdline_file = utils.PathJoin("/proc", str(pid), "cmdline")
 561     try:
 562       cmdline = utils.ReadFile(cmdline_file)
 563     except EnvironmentError, err:
 564       raise errors.HypervisorError("Can't open cmdline file for pid %s: %s" %
 565                                    (pid, err))
 566
 567     instance = None
 568     memory = 0
 569     vcpus = 0
 570
 571     arg_list = cmdline.split("\x00")
 572     while arg_list:
 573       arg = arg_list.pop(0)
 574       if arg == "-name":
 575         instance = arg_list.pop(0)
 576       elif arg == "-m":
 577         memory = int(arg_list.pop(0))
 578       elif arg == "-smp":
 579         vcpus = int(arg_list.pop(0))
 580
 581     if instance is None:
 582       raise errors.HypervisorError("Pid %s doesn't contain a ganeti kvm"
 583                                    " instance" % pid)
 584
 585     return (instance, memory, vcpus)
 586
 587   def _InstancePidAlive(self, instance_name):
 588     """Returns the instance pidfile, pid, and liveness.
 589
 590     @type instance_name: string
 591     @param instance_name: instance name
 592     @rtype: tuple
 593     @return: (pid file name, pid, liveness)
 594
 595     """
 596     pidfile = self._InstancePidFile(instance_name)
 597     pid = utils.ReadPidFile(pidfile)
 598
 599     alive = False
 600     try:
 601       cmd_instance = self._InstancePidInfo(pid)[0]
 602       alive = (cmd_instance == instance_name)
 603     except errors.HypervisorError:
 604       pass
 605
 606     return (pidfile, pid, alive)
 607
 608   def _CheckDown(self, instance_name):
 609     """Raises an error unless the given instance is down.
 610
 611     """
 612     alive = self._InstancePidAlive(instance_name)[2]
 613     if alive:
 614       raise errors.HypervisorError("Failed to start instance %s: %s" %
 615                                    (instance_name, "already running"))
 616
 617   @classmethod
 618   def _InstanceMonitor(cls, instance_name):
 619     """Returns the instance monitor socket name
 620
 621     """
 622     return utils.PathJoin(cls._CTRL_DIR, "%s.monitor" % instance_name)
 623
 624   @classmethod
 625   def _InstanceSerial(cls, instance_name):
 626     """Returns the instance serial socket name
 627
 628     """
 629     return utils.PathJoin(cls._CTRL_DIR, "%s.serial" % instance_name)
 630
 631   @classmethod
 632   def _InstanceQmpMonitor(cls, instance_name):
 633     """Returns the instance serial QMP socket name
 634
 635     """
 636     return utils.PathJoin(cls._CTRL_DIR, "%s.qmp" % instance_name)
 637
 638   @staticmethod
 639   def _SocatUnixConsoleParams():
 640     """Returns the correct parameters for socat
 641
 642     If we have a new-enough socat we can use raw mode with an escape character.
 643
 644     """
 645     if constants.SOCAT_USE_ESCAPE:
 646       return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE
 647     else:
 648       return "echo=0,icanon=0"
 649
 650   @classmethod
 651   def _InstanceKVMRuntime(cls, instance_name):
 652     """Returns the instance KVM runtime filename
 653
 654     """
 655     return utils.PathJoin(cls._CONF_DIR, "%s.runtime" % instance_name)
 656
 657   @classmethod
 658   def _InstanceChrootDir(cls, instance_name):
 659     """Returns the name of the KVM chroot dir of the instance
 660
 661     """
 662     return utils.PathJoin(cls._CHROOT_DIR, instance_name)
 663
 664   @classmethod
 665   def _InstanceNICDir(cls, instance_name):
 666     """Returns the name of the directory holding the tap device files for a
 667     given instance.
 668
 669     """
 670     return utils.PathJoin(cls._NICS_DIR, instance_name)
 671
 672   @classmethod
 673   def _InstanceNICFile(cls, instance_name, seq):
 674     """Returns the name of the file containing the tap device for a given NIC
 675
 676     """
 677     return utils.PathJoin(cls._InstanceNICDir(instance_name), str(seq))
 678
 679   @classmethod
 680   def _InstanceKeymapFile(cls, instance_name):
 681     """Returns the name of the file containing the keymap for a given instance
 682
 683     """
 684     return utils.PathJoin(cls._KEYMAP_DIR, instance_name)
 685
 686   @classmethod
 687   def _TryReadUidFile(cls, uid_file):
 688     """Try to read a uid file
 689
 690     """
 691     if os.path.exists(uid_file):
 692       try:
 693         uid = int(utils.ReadOneLineFile(uid_file))
 694         return uid
 695       except EnvironmentError:
 696         logging.warning("Can't read uid file", exc_info=True)
 697       except (TypeError, ValueError):
 698         logging.warning("Can't parse uid file contents", exc_info=True)
 699     return None
 700
 701   @classmethod
 702   def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):
 703     """Removes an instance's rutime sockets/files/dirs.
 704
 705     """
 706     utils.RemoveFile(pidfile)
 707     utils.RemoveFile(cls._InstanceMonitor(instance_name))
 708     utils.RemoveFile(cls._InstanceSerial(instance_name))
 709     utils.RemoveFile(cls._InstanceQmpMonitor(instance_name))
 710     utils.RemoveFile(cls._InstanceKVMRuntime(instance_name))
 711     utils.RemoveFile(cls._InstanceKeymapFile(instance_name))
 712     uid_file = cls._InstanceUidFile(instance_name)
 713     uid = cls._TryReadUidFile(uid_file)
 714     utils.RemoveFile(uid_file)
 715     if uid is not None:
 716       uidpool.ReleaseUid(uid)
 717     try:
 718       shutil.rmtree(cls._InstanceNICDir(instance_name))
 719     except OSError, err:
 720       if err.errno != errno.ENOENT:
 721         raise
 722     try:
 723       chroot_dir = cls._InstanceChrootDir(instance_name)
 724       utils.RemoveDir(chroot_dir)
 725     except OSError, err:
 726       if err.errno == errno.ENOTEMPTY:
 727         # The chroot directory is expected to be empty, but it isn't.
 728         new_chroot_dir = tempfile.mkdtemp(dir=cls._CHROOT_QUARANTINE_DIR,
 729                                           prefix="%s-%s-" %
 730                                           (instance_name,
 731                                            utils.TimestampForFilename()))
 732         logging.warning("The chroot directory of instance %s can not be"
 733                         " removed as it is not empty. Moving it to the"
 734                         " quarantine instead. Please investigate the"
 735                         " contents (%s) and clean up manually",
 736                         instance_name, new_chroot_dir)
 737         utils.RenameFile(chroot_dir, new_chroot_dir)
 738       else:
 739         raise
 740
 741   @staticmethod
 742   def _ConfigureNIC(instance, seq, nic, tap):
 743     """Run the network configuration script for a specified NIC
 744
 745     @param instance: instance we're acting on
 746     @type instance: instance object
 747     @param seq: nic sequence number
 748     @type seq: int
 749     @param nic: nic we're acting on
 750     @type nic: nic object
 751     @param tap: the host's tap interface this NIC corresponds to
 752     @type tap: str
 753
 754     """
 755     if instance.tags:
 756       tags = " ".join(instance.tags)
 757     else:
 758       tags = ""
 759
 760     env = {
 761       "PATH": "%s:/sbin:/usr/sbin" % os.environ["PATH"],
 762       "INSTANCE": instance.name,
 763       "MAC": nic.mac,
 764       "MODE": nic.nicparams[constants.NIC_MODE],
 765       "INTERFACE": tap,
 766       "INTERFACE_INDEX": str(seq),
 767       "TAGS": tags,
 768     }
 769
 770     if nic.ip:
 771       env["IP"] = nic.ip
 772
 773     if nic.nicparams[constants.NIC_LINK]:
 774       env["LINK"] = nic.nicparams[constants.NIC_LINK]
 775
 776     if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
 777       env["BRIDGE"] = nic.nicparams[constants.NIC_LINK]
 778
 779     result = utils.RunCmd([constants.KVM_IFUP, tap], env=env)
 780     if result.failed:
 781       raise errors.HypervisorError("Failed to configure interface %s: %s."
 782                                    " Network configuration script output: %s" %
 783                                    (tap, result.fail_reason, result.output))
 784
 785   @staticmethod
 786   def _VerifyAffinityPackage():
 787     if affinity is None:
 788       raise errors.HypervisorError("affinity Python package not"
 789         " found; cannot use CPU pinning under KVM")
 790
 791   @staticmethod
 792   def _BuildAffinityCpuMask(cpu_list):
 793     """Create a CPU mask suitable for sched_setaffinity from a list of
 794     CPUs.
 795
 796     See man taskset for more info on sched_setaffinity masks.
 797     For example: [ 0, 2, 5, 6 ] will return 101 (0x65, 0..01100101).
 798
 799     @type cpu_list: list of int
 800     @param cpu_list: list of physical CPU numbers to map to vCPUs in order
 801     @rtype: int
 802     @return: a bit mask of CPU affinities
 803
 804     """
 805     if cpu_list == constants.CPU_PINNING_OFF:
 806       return constants.CPU_PINNING_ALL_KVM
 807     else:
 808       return sum(2 ** cpu for cpu in cpu_list)
 809
 810   @classmethod
 811   def _AssignCpuAffinity(cls, cpu_mask, process_id, thread_dict):
 812     """Change CPU affinity for running VM according to given CPU mask.
 813
 814     @param cpu_mask: CPU mask as given by the user. e.g. "0-2,4:all:1,3"
 815     @type cpu_mask: string
 816     @param process_id: process ID of KVM process. Used to pin entire VM
 817                        to physical CPUs.
 818     @type process_id: int
 819     @param thread_dict: map of virtual CPUs to KVM thread IDs
 820     @type thread_dict: dict int:int
 821
 822     """
 823     # Convert the string CPU mask to a list of list of int's
 824     cpu_list = utils.ParseMultiCpuMask(cpu_mask)
 825
 826     if len(cpu_list) == 1:
 827       all_cpu_mapping = cpu_list[0]
 828       if all_cpu_mapping == constants.CPU_PINNING_OFF:
 829         # If CPU pinning has 1 entry that's "all", then do nothing
 830         pass
 831       else:
 832         # If CPU pinning has one non-all entry, map the entire VM to
 833         # one set of physical CPUs
 834         cls._VerifyAffinityPackage()
 835         affinity.set_process_affinity_mask(process_id,
 836           cls._BuildAffinityCpuMask(all_cpu_mapping))
 837     else:
 838       # The number of vCPUs mapped should match the number of vCPUs
 839       # reported by KVM. This was already verified earlier, so
 840       # here only as a sanity check.
 841       assert len(thread_dict) == len(cpu_list)
 842       cls._VerifyAffinityPackage()
 843
 844       # For each vCPU, map it to the proper list of physical CPUs
 845       for vcpu, i in zip(cpu_list, range(len(cpu_list))):
 846         affinity.set_process_affinity_mask(thread_dict[i],
 847           cls._BuildAffinityCpuMask(vcpu))
 848
 849   def _GetVcpuThreadIds(self, instance_name):
 850     """Get a mapping of vCPU no. to thread IDs for the instance
 851
 852     @type instance_name: string
 853     @param instance_name: instance in question
 854     @rtype: dictionary of int:int
 855     @return: a dictionary mapping vCPU numbers to thread IDs
 856
 857     """
 858     result = {}
 859     output = self._CallMonitorCommand(instance_name, self._CPU_INFO_CMD)
 860     for line in output.stdout.splitlines():
 861       match = self._CPU_INFO_RE.search(line)
 862       if not match:
 863         continue
 864       grp = map(int, match.groups())
 865       result[grp[0]] = grp[1]
 866
 867     return result
 868
 869   def _ExecuteCpuAffinity(self, instance_name, cpu_mask):
 870     """Complete CPU pinning.
 871
 872     @type instance_name: string
 873     @param instance_name: name of instance
 874     @type cpu_mask: string
 875     @param cpu_mask: CPU pinning mask as entered by user
 876
 877     """
 878     # Get KVM process ID, to be used if need to pin entire VM
 879     _, pid, _ = self._InstancePidAlive(instance_name)
 880     # Get vCPU thread IDs, to be used if need to pin vCPUs separately
 881     thread_dict = self._GetVcpuThreadIds(instance_name)
 882     # Run CPU pinning, based on configured mask
 883     self._AssignCpuAffinity(cpu_mask, pid, thread_dict)
 884
 885   def ListInstances(self):
 886     """Get the list of running instances.
 887
 888     We can do this by listing our live instances directory and
 889     checking whether the associated kvm process is still alive.
 890
 891     """
 892     result = []
 893     for name in os.listdir(self._PIDS_DIR):
 894       if self._InstancePidAlive(name)[2]:
 895         result.append(name)
 896     return result
 897
 898   def GetInstanceInfo(self, instance_name):
 899     """Get instance properties.
 900
 901     @type instance_name: string
 902     @param instance_name: the instance name
 903     @rtype: tuple of strings
 904     @return: (name, id, memory, vcpus, stat, times)
 905
 906     """
 907     _, pid, alive = self._InstancePidAlive(instance_name)
 908     if not alive:
 909       return None
 910
 911     _, memory, vcpus = self._InstancePidInfo(pid)
 912     istat = "---b-"
 913     times = "0"
 914
 915     try:
 916       qmp = QmpConnection(self._InstanceQmpMonitor(instance_name))
 917       qmp.connect()
 918       vcpus = len(qmp.Execute("query-cpus")[qmp.RETURN_KEY])
 919       # Will fail if ballooning is not enabled, but we can then just resort to
 920       # the value above.
 921       mem_bytes = qmp.Execute("query-balloon")[qmp.RETURN_KEY][qmp.ACTUAL_KEY]
 922       memory = mem_bytes / 1048576
 923     except errors.HypervisorError:
 924       pass
 925
 926     return (instance_name, pid, memory, vcpus, istat, times)
 927
 928   def GetAllInstancesInfo(self):
 929     """Get properties of all instances.
 930
 931     @return: list of tuples (name, id, memory, vcpus, stat, times)
 932
 933     """
 934     data = []
 935     for name in os.listdir(self._PIDS_DIR):
 936       try:
 937         info = self.GetInstanceInfo(name)
 938       except errors.HypervisorError:
 939         # Ignore exceptions due to instances being shut down
 940         continue
 941       if info:
 942         data.append(info)
 943     return data
 944
 945   def _GenerateKVMRuntime(self, instance, block_devices, startup_paused):
 946     """Generate KVM information to start an instance.
 947
 948     @attention: this function must not have any side-effects; for
 949         example, it must not write to the filesystem, or read values
 950         from the current system the are expected to differ between
 951         nodes, since it is only run once at instance startup;
 952         actions/kvm arguments that can vary between systems should be
 953         done in L{_ExecuteKVMRuntime}
 954
 955     """
 956     # pylint: disable=R0914,R0915
 957     _, v_major, v_min, _ = self._GetKVMVersion()
 958
 959     pidfile = self._InstancePidFile(instance.name)
 960     kvm = constants.KVM_PATH
 961     kvm_cmd = [kvm]
 962     # used just by the vnc server, if enabled
 963     kvm_cmd.extend(["-name", instance.name])
 964     kvm_cmd.extend(["-m", instance.beparams[constants.BE_MAXMEM]])
 965     kvm_cmd.extend(["-smp", instance.beparams[constants.BE_VCPUS]])
 966     kvm_cmd.extend(["-pidfile", pidfile])
 967     kvm_cmd.extend(["-balloon", "virtio"])
 968     kvm_cmd.extend(["-daemonize"])
 969     if not instance.hvparams[constants.HV_ACPI]:
 970       kvm_cmd.extend(["-no-acpi"])
 971     if instance.hvparams[constants.HV_REBOOT_BEHAVIOR] == \
 972         constants.INSTANCE_REBOOT_EXIT:
 973       kvm_cmd.extend(["-no-reboot"])
 974
 975     hvp = instance.hvparams
 976     kernel_path = hvp[constants.HV_KERNEL_PATH]
 977     if kernel_path:
 978       boot_disk = boot_cdrom = boot_floppy = boot_network = False
 979     else:
 980       boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
 981       boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM
 982       boot_floppy = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_FLOPPY
 983       boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
 984
 985     self.ValidateParameters(hvp)
 986
 987     if startup_paused:
 988       kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
 989
 990     if hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED:
 991       kvm_cmd.extend(["-enable-kvm"])
 992     elif hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED:
 993       kvm_cmd.extend(["-disable-kvm"])
 994
 995     if boot_network:
 996       kvm_cmd.extend(["-boot", "n"])
 997
 998     # whether this is an older KVM version that uses the boot=on flag
 999     # on devices
1000     needs_boot_flag = (v_major, v_min) < (0, 14)
1001
1002     disk_type = hvp[constants.HV_DISK_TYPE]
1003     if disk_type == constants.HT_DISK_PARAVIRTUAL:
1004       if_val = ",if=virtio"
1005     else:
1006       if_val = ",if=%s" % disk_type
1007     # Cache mode
1008     disk_cache = hvp[constants.HV_DISK_CACHE]
1009     if instance.disk_template in constants.DTS_EXT_MIRROR:
1010       if disk_cache != "none":
1011         # TODO: make this a hard error, instead of a silent overwrite
1012         logging.warning("KVM: overriding disk_cache setting '%s' with 'none'"
1013                         " to prevent shared storage corruption on migration",
1014                         disk_cache)
1015       cache_val = ",cache=none"
1016     elif disk_cache != constants.HT_CACHE_DEFAULT:
1017       cache_val = ",cache=%s" % disk_cache
1018     else:
1019       cache_val = ""
1020     for cfdev, dev_path in block_devices:
1021       if cfdev.mode != constants.DISK_RDWR:
1022         raise errors.HypervisorError("Instance has read-only disks which"
1023                                      " are not supported by KVM")
1024       # TODO: handle FD_LOOP and FD_BLKTAP (?)
1025       boot_val = ""
1026       if boot_disk:
1027         kvm_cmd.extend(["-boot", "c"])
1028         boot_disk = False
1029         if needs_boot_flag and disk_type != constants.HT_DISK_IDE:
1030           boot_val = ",boot=on"
1031
1032       drive_val = "file=%s,format=raw%s%s%s" % (dev_path, if_val, boot_val,
1033                                                 cache_val)
1034       kvm_cmd.extend(["-drive", drive_val])
1035
1036     #Now we can specify a different device type for CDROM devices.
1037     cdrom_disk_type = hvp[constants.HV_KVM_CDROM_DISK_TYPE]
1038     if not cdrom_disk_type:
1039       cdrom_disk_type = disk_type
1040
1041     iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
1042     if iso_image:
1043       options = ",format=raw,media=cdrom"
1044       # set cdrom 'if' type
1045       if boot_cdrom:
1046         actual_cdrom_type = constants.HT_DISK_IDE
1047       elif cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1048         actual_cdrom_type = "virtio"
1049       else:
1050         actual_cdrom_type = cdrom_disk_type
1051       if_val = ",if=%s" % actual_cdrom_type
1052       # set boot flag, if needed
1053       boot_val = ""
1054       if boot_cdrom:
1055         kvm_cmd.extend(["-boot", "d"])
1056         if needs_boot_flag:
1057           boot_val = ",boot=on"
1058       # and finally build the entire '-drive' value
1059       drive_val = "file=%s%s%s%s" % (iso_image, options, if_val, boot_val)
1060       kvm_cmd.extend(["-drive", drive_val])
1061
1062     iso_image2 = hvp[constants.HV_KVM_CDROM2_IMAGE_PATH]
1063     if iso_image2:
1064       options = ",format=raw,media=cdrom"
1065       if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1066         if_val = ",if=virtio"
1067       else:
1068         if_val = ",if=%s" % cdrom_disk_type
1069       drive_val = "file=%s%s%s" % (iso_image2, options, if_val)
1070       kvm_cmd.extend(["-drive", drive_val])
1071
1072     floppy_image = hvp[constants.HV_KVM_FLOPPY_IMAGE_PATH]
1073     if floppy_image:
1074       options = ",format=raw,media=disk"
1075       if boot_floppy:
1076         kvm_cmd.extend(["-boot", "a"])
1077         options = "%s,boot=on" % options
1078       if_val = ",if=floppy"
1079       options = "%s%s" % (options, if_val)
1080       drive_val = "file=%s%s" % (floppy_image, options)
1081       kvm_cmd.extend(["-drive", drive_val])
1082
1083     if kernel_path:
1084       kvm_cmd.extend(["-kernel", kernel_path])
1085       initrd_path = hvp[constants.HV_INITRD_PATH]
1086       if initrd_path:
1087         kvm_cmd.extend(["-initrd", initrd_path])
1088       root_append = ["root=%s" % hvp[constants.HV_ROOT_PATH],
1089                      hvp[constants.HV_KERNEL_ARGS]]
1090       if hvp[constants.HV_SERIAL_CONSOLE]:
1091         root_append.append("console=ttyS0,38400")
1092       kvm_cmd.extend(["-append", " ".join(root_append)])
1093
1094     mem_path = hvp[constants.HV_MEM_PATH]
1095     if mem_path:
1096       kvm_cmd.extend(["-mem-path", mem_path, "-mem-prealloc"])
1097
1098     monitor_dev = ("unix:%s,server,nowait" %
1099                    self._InstanceMonitor(instance.name))
1100     kvm_cmd.extend(["-monitor", monitor_dev])
1101     if hvp[constants.HV_SERIAL_CONSOLE]:
1102       serial_dev = ("unix:%s,server,nowait" %
1103                     self._InstanceSerial(instance.name))
1104       kvm_cmd.extend(["-serial", serial_dev])
1105     else:
1106       kvm_cmd.extend(["-serial", "none"])
1107
1108     mouse_type = hvp[constants.HV_USB_MOUSE]
1109     vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
1110     spice_bind = hvp[constants.HV_KVM_SPICE_BIND]
1111     spice_ip_version = None
1112
1113     if mouse_type:
1114       kvm_cmd.extend(["-usb"])
1115       kvm_cmd.extend(["-usbdevice", mouse_type])
1116     elif vnc_bind_address:
1117       kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
1118
1119     if vnc_bind_address:
1120       if netutils.IP4Address.IsValid(vnc_bind_address):
1121         if instance.network_port > constants.VNC_BASE_PORT:
1122           display = instance.network_port - constants.VNC_BASE_PORT
1123           if vnc_bind_address == constants.IP4_ADDRESS_ANY:
1124             vnc_arg = ":%d" % (display)
1125           else:
1126             vnc_arg = "%s:%d" % (vnc_bind_address, display)
1127         else:
1128           logging.error("Network port is not a valid VNC display (%d < %d)."
1129                         " Not starting VNC", instance.network_port,
1130                         constants.VNC_BASE_PORT)
1131           vnc_arg = "none"
1132
1133         # Only allow tls and other option when not binding to a file, for now.
1134         # kvm/qemu gets confused otherwise about the filename to use.
1135         vnc_append = ""
1136         if hvp[constants.HV_VNC_TLS]:
1137           vnc_append = "%s,tls" % vnc_append
1138           if hvp[constants.HV_VNC_X509_VERIFY]:
1139             vnc_append = "%s,x509verify=%s" % (vnc_append,
1140                                                hvp[constants.HV_VNC_X509])
1141           elif hvp[constants.HV_VNC_X509]:
1142             vnc_append = "%s,x509=%s" % (vnc_append,
1143                                          hvp[constants.HV_VNC_X509])
1144         if hvp[constants.HV_VNC_PASSWORD_FILE]:
1145           vnc_append = "%s,password" % vnc_append
1146
1147         vnc_arg = "%s%s" % (vnc_arg, vnc_append)
1148
1149       else:
1150         vnc_arg = "unix:%s/%s.vnc" % (vnc_bind_address, instance.name)
1151
1152       kvm_cmd.extend(["-vnc", vnc_arg])
1153     elif spice_bind:
1154       # FIXME: this is wrong here; the iface ip address differs
1155       # between systems, so it should be done in _ExecuteKVMRuntime
1156       if netutils.IsValidInterface(spice_bind):
1157         # The user specified a network interface, we have to figure out the IP
1158         # address.
1159         addresses = netutils.GetInterfaceIpAddresses(spice_bind)
1160         spice_ip_version = hvp[constants.HV_KVM_SPICE_IP_VERSION]
1161
1162         # if the user specified an IP version and the interface does not
1163         # have that kind of IP addresses, throw an exception
1164         if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
1165           if not addresses[spice_ip_version]:
1166             raise errors.HypervisorError("spice: unable to get an IPv%s address"
1167                                          " for %s" % (spice_ip_version,
1168                                                       spice_bind))
1169
1170         # the user did not specify an IP version, we have to figure it out
1171         elif (addresses[constants.IP4_VERSION] and
1172               addresses[constants.IP6_VERSION]):
1173           # we have both ipv4 and ipv6, let's use the cluster default IP
1174           # version
1175           cluster_family = ssconf.SimpleStore().GetPrimaryIPFamily()
1176           spice_ip_version = \
1177             netutils.IPAddress.GetVersionFromAddressFamily(cluster_family)
1178         elif addresses[constants.IP4_VERSION]:
1179           spice_ip_version = constants.IP4_VERSION
1180         elif addresses[constants.IP6_VERSION]:
1181           spice_ip_version = constants.IP6_VERSION
1182         else:
1183           raise errors.HypervisorError("spice: unable to get an IP address"
1184                                        " for %s" % (spice_bind))
1185
1186         spice_address = addresses[spice_ip_version][0]
1187
1188       else:
1189         # spice_bind is known to be a valid IP address, because
1190         # ValidateParameters checked it.
1191         spice_address = spice_bind
1192
1193       spice_arg = "addr=%s" % spice_address
1194       if hvp[constants.HV_KVM_SPICE_USE_TLS]:
1195         spice_arg = "%s,tls-port=%s,x509-cacert-file=%s" % (spice_arg,
1196             instance.network_port, constants.SPICE_CACERT_FILE)
1197         spice_arg = "%s,x509-key-file=%s,x509-cert-file=%s" % (spice_arg,
1198             constants.SPICE_CERT_FILE, constants.SPICE_CERT_FILE)
1199         tls_ciphers = hvp[constants.HV_KVM_SPICE_TLS_CIPHERS]
1200         if tls_ciphers:
1201           spice_arg = "%s,tls-ciphers=%s" % (spice_arg, tls_ciphers)
1202       else:
1203         spice_arg = "%s,port=%s" % (spice_arg, instance.network_port)
1204
1205       if not hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]:
1206         spice_arg = "%s,disable-ticketing" % spice_arg
1207
1208       if spice_ip_version:
1209         spice_arg = "%s,ipv%s" % (spice_arg, spice_ip_version)
1210
1211       # Image compression options
1212       img_lossless = hvp[constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR]
1213       img_jpeg = hvp[constants.HV_KVM_SPICE_JPEG_IMG_COMPR]
1214       img_zlib_glz = hvp[constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR]
1215       if img_lossless:
1216         spice_arg = "%s,image-compression=%s" % (spice_arg, img_lossless)
1217       if img_jpeg:
1218         spice_arg = "%s,jpeg-wan-compression=%s" % (spice_arg, img_jpeg)
1219       if img_zlib_glz:
1220         spice_arg = "%s,zlib-glz-wan-compression=%s" % (spice_arg, img_zlib_glz)
1221
1222       # Video stream detection
1223       video_streaming = hvp[constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION]
1224       if video_streaming:
1225         spice_arg = "%s,streaming-video=%s" % (spice_arg, video_streaming)
1226
1227       # Audio compression, by default in qemu-kvm it is on
1228       if not hvp[constants.HV_KVM_SPICE_AUDIO_COMPR]:
1229         spice_arg = "%s,playback-compression=off" % spice_arg
1230       if not hvp[constants.HV_KVM_SPICE_USE_VDAGENT]:
1231         spice_arg = "%s,agent-mouse=off" % spice_arg
1232       else:
1233         # Enable the spice agent communication channel between the host and the
1234         # agent.
1235         kvm_cmd.extend(["-device", "virtio-serial-pci"])
1236         kvm_cmd.extend(["-device", "virtserialport,chardev=spicechannel0,"
1237                                                    "name=com.redhat.spice.0"])
1238         kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"])
1239
1240       logging.info("KVM: SPICE will listen on port %s", instance.network_port)
1241       kvm_cmd.extend(["-spice", spice_arg])
1242
1243       # Tell kvm to use the paravirtualized graphic card, optimized for SPICE
1244       kvm_cmd.extend(["-vga", "qxl"])
1245
1246     else:
1247       kvm_cmd.extend(["-nographic"])
1248
1249     if hvp[constants.HV_USE_LOCALTIME]:
1250       kvm_cmd.extend(["-localtime"])
1251
1252     if hvp[constants.HV_KVM_USE_CHROOT]:
1253       kvm_cmd.extend(["-chroot", self._InstanceChrootDir(instance.name)])
1254
1255     # Save the current instance nics, but defer their expansion as parameters,
1256     # as we'll need to generate executable temp files for them.
1257     kvm_nics = instance.nics
1258     hvparams = hvp
1259
1260     return (kvm_cmd, kvm_nics, hvparams)
1261
1262   def _WriteKVMRuntime(self, instance_name, data):
1263     """Write an instance's KVM runtime
1264
1265     """
1266     try:
1267       utils.WriteFile(self._InstanceKVMRuntime(instance_name),
1268                       data=data)
1269     except EnvironmentError, err:
1270       raise errors.HypervisorError("Failed to save KVM runtime file: %s" % err)
1271
1272   def _ReadKVMRuntime(self, instance_name):
1273     """Read an instance's KVM runtime
1274
1275     """
1276     try:
1277       file_content = utils.ReadFile(self._InstanceKVMRuntime(instance_name))
1278     except EnvironmentError, err:
1279       raise errors.HypervisorError("Failed to load KVM runtime file: %s" % err)
1280     return file_content
1281
1282   def _SaveKVMRuntime(self, instance, kvm_runtime):
1283     """Save an instance's KVM runtime
1284
1285     """
1286     kvm_cmd, kvm_nics, hvparams = kvm_runtime
1287     serialized_nics = [nic.ToDict() for nic in kvm_nics]
1288     serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams))
1289     self._WriteKVMRuntime(instance.name, serialized_form)
1290
1291   def _LoadKVMRuntime(self, instance, serialized_runtime=None):
1292     """Load an instance's KVM runtime
1293
1294     """
1295     if not serialized_runtime:
1296       serialized_runtime = self._ReadKVMRuntime(instance.name)
1297     loaded_runtime = serializer.Load(serialized_runtime)
1298     kvm_cmd, serialized_nics, hvparams = loaded_runtime
1299     kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics]
1300     return (kvm_cmd, kvm_nics, hvparams)
1301
1302   def _RunKVMCmd(self, name, kvm_cmd, tap_fds=None):
1303     """Run the KVM cmd and check for errors
1304
1305     @type name: string
1306     @param name: instance name
1307     @type kvm_cmd: list of strings
1308     @param kvm_cmd: runcmd input for kvm
1309     @type tap_fds: list of int
1310     @param tap_fds: fds of tap devices opened by Ganeti
1311
1312     """
1313     try:
1314       result = utils.RunCmd(kvm_cmd, noclose_fds=tap_fds)
1315     finally:
1316       for fd in tap_fds:
1317         utils_wrapper.CloseFdNoError(fd)
1318
1319     if result.failed:
1320       raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
1321                                    (name, result.fail_reason, result.output))
1322     if not self._InstancePidAlive(name)[2]:
1323       raise errors.HypervisorError("Failed to start instance %s" % name)
1324
1325   def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None):
1326     """Execute a KVM cmd, after completing it with some last minute data.
1327
1328     @type incoming: tuple of strings
1329     @param incoming: (target_host_ip, port)
1330
1331     """
1332     # Small _ExecuteKVMRuntime hv parameters programming howto:
1333     #  - conf_hvp contains the parameters as configured on ganeti. they might
1334     #    have changed since the instance started; only use them if the change
1335     #    won't affect the inside of the instance (which hasn't been rebooted).
1336     #  - up_hvp contains the parameters as they were when the instance was
1337     #    started, plus any new parameter which has been added between ganeti
1338     #    versions: it is paramount that those default to a value which won't
1339     #    affect the inside of the instance as well.
1340     conf_hvp = instance.hvparams
1341     name = instance.name
1342     self._CheckDown(name)
1343
1344     temp_files = []
1345
1346     kvm_cmd, kvm_nics, up_hvp = kvm_runtime
1347     up_hvp = objects.FillDict(conf_hvp, up_hvp)
1348
1349     _, v_major, v_min, _ = self._GetKVMVersion()
1350
1351     # We know it's safe to run as a different user upon migration, so we'll use
1352     # the latest conf, from conf_hvp.
1353     security_model = conf_hvp[constants.HV_SECURITY_MODEL]
1354     if security_model == constants.HT_SM_USER:
1355       kvm_cmd.extend(["-runas", conf_hvp[constants.HV_SECURITY_DOMAIN]])
1356
1357     keymap = conf_hvp[constants.HV_KEYMAP]
1358     if keymap:
1359       keymap_path = self._InstanceKeymapFile(name)
1360       # If a keymap file is specified, KVM won't use its internal defaults. By
1361       # first including the "en-us" layout, an error on loading the actual
1362       # layout (e.g. because it can't be found) won't lead to a non-functional
1363       # keyboard. A keyboard with incorrect keys is still better than none.
1364       utils.WriteFile(keymap_path, data="include en-us\ninclude %s\n" % keymap)
1365       kvm_cmd.extend(["-k", keymap_path])
1366
1367     # We have reasons to believe changing something like the nic driver/type
1368     # upon migration won't exactly fly with the instance kernel, so for nic
1369     # related parameters we'll use up_hvp
1370     tapfds = []
1371     taps = []
1372     if not kvm_nics:
1373       kvm_cmd.extend(["-net", "none"])
1374     else:
1375       vnet_hdr = False
1376       tap_extra = ""
1377       nic_type = up_hvp[constants.HV_NIC_TYPE]
1378       if nic_type == constants.HT_NIC_PARAVIRTUAL:
1379         # From version 0.12.0, kvm uses a new sintax for network configuration.
1380         if (v_major, v_min) >= (0, 12):
1381           nic_model = "virtio-net-pci"
1382           vnet_hdr = True
1383         else:
1384           nic_model = "virtio"
1385
1386         if up_hvp[constants.HV_VHOST_NET]:
1387           # vhost_net is only available from version 0.13.0 or newer
1388           if (v_major, v_min) >= (0, 13):
1389             tap_extra = ",vhost=on"
1390           else:
1391             raise errors.HypervisorError("vhost_net is configured"
1392                                         " but it is not available")
1393       else:
1394         nic_model = nic_type
1395
1396       for nic_seq, nic in enumerate(kvm_nics):
1397         tapname, tapfd = _OpenTap(vnet_hdr)
1398         tapfds.append(tapfd)
1399         taps.append(tapname)
1400         if (v_major, v_min) >= (0, 12):
1401           nic_val = "%s,mac=%s,netdev=netdev%s" % (nic_model, nic.mac, nic_seq)
1402           tap_val = "type=tap,id=netdev%s,fd=%d%s" % (nic_seq, tapfd, tap_extra)
1403           kvm_cmd.extend(["-netdev", tap_val, "-device", nic_val])
1404         else:
1405           nic_val = "nic,vlan=%s,macaddr=%s,model=%s" % (nic_seq,
1406                                                          nic.mac, nic_model)
1407           tap_val = "tap,vlan=%s,fd=%d" % (nic_seq, tapfd)
1408           kvm_cmd.extend(["-net", tap_val, "-net", nic_val])
1409
1410     if incoming:
1411       target, port = incoming
1412       kvm_cmd.extend(["-incoming", "tcp:%s:%s" % (target, port)])
1413
1414     # Changing the vnc password doesn't bother the guest that much. At most it
1415     # will surprise people who connect to it. Whether positively or negatively
1416     # it's debatable.
1417     vnc_pwd_file = conf_hvp[constants.HV_VNC_PASSWORD_FILE]
1418     vnc_pwd = None
1419     if vnc_pwd_file:
1420       try:
1421         vnc_pwd = utils.ReadOneLineFile(vnc_pwd_file, strict=True)
1422       except EnvironmentError, err:
1423         raise errors.HypervisorError("Failed to open VNC password file %s: %s"
1424                                      % (vnc_pwd_file, err))
1425
1426     if conf_hvp[constants.HV_KVM_USE_CHROOT]:
1427       utils.EnsureDirs([(self._InstanceChrootDir(name),
1428                          constants.SECURE_DIR_MODE)])
1429
1430     # Automatically enable QMP if version is >= 0.14
1431     if (v_major, v_min) >= (0, 14):
1432       logging.debug("Enabling QMP")
1433       kvm_cmd.extend(["-qmp", "unix:%s,server,nowait" %
1434                     self._InstanceQmpMonitor(instance.name)])
1435
1436     # Configure the network now for starting instances and bridged interfaces,
1437     # during FinalizeMigration for incoming instances' routed interfaces
1438     for nic_seq, nic in enumerate(kvm_nics):
1439       if (incoming and
1440           nic.nicparams[constants.NIC_MODE] != constants.NIC_MODE_BRIDGED):
1441         continue
1442       self._ConfigureNIC(instance, nic_seq, nic, taps[nic_seq])
1443
1444     # CPU affinity requires kvm to start paused, so we set this flag if the
1445     # instance is not already paused and if we are not going to accept a
1446     # migrating instance. In the latter case, pausing is not needed.
1447     start_kvm_paused = not (_KVM_START_PAUSED_FLAG in kvm_cmd) and not incoming
1448     if start_kvm_paused:
1449       kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
1450
1451     # Note: CPU pinning is using up_hvp since changes take effect
1452     # during instance startup anyway, and to avoid problems when soft
1453     # rebooting the instance.
1454     cpu_pinning = False
1455     if up_hvp.get(constants.HV_CPU_MASK, None):
1456       cpu_pinning = True
1457
1458     if security_model == constants.HT_SM_POOL:
1459       ss = ssconf.SimpleStore()
1460       uid_pool = uidpool.ParseUidPool(ss.GetUidPool(), separator="\n")
1461       all_uids = set(uidpool.ExpandUidPool(uid_pool))
1462       uid = uidpool.RequestUnusedUid(all_uids)
1463       try:
1464         username = pwd.getpwuid(uid.GetUid()).pw_name
1465         kvm_cmd.extend(["-runas", username])
1466         self._RunKVMCmd(name, kvm_cmd, tapfds)
1467       except:
1468         uidpool.ReleaseUid(uid)
1469         raise
1470       else:
1471         uid.Unlock()
1472         utils.WriteFile(self._InstanceUidFile(name), data=uid.AsStr())
1473     else:
1474       self._RunKVMCmd(name, kvm_cmd, tapfds)
1475
1476     utils.EnsureDirs([(self._InstanceNICDir(instance.name),
1477                      constants.RUN_DIRS_MODE)])
1478     for nic_seq, tap in enumerate(taps):
1479       utils.WriteFile(self._InstanceNICFile(instance.name, nic_seq),
1480                       data=tap)
1481
1482     if vnc_pwd:
1483       change_cmd = "change vnc password %s" % vnc_pwd
1484       self._CallMonitorCommand(instance.name, change_cmd)
1485
1486     # Setting SPICE password. We are not vulnerable to malicious passwordless
1487     # connection attempts because SPICE by default does not allow connections
1488     # if neither a password nor the "disable_ticketing" options are specified.
1489     # As soon as we send the password via QMP, that password is a valid ticket
1490     # for connection.
1491     spice_password_file = conf_hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]
1492     if spice_password_file:
1493       spice_pwd = ""
1494       try:
1495         spice_pwd = utils.ReadOneLineFile(spice_password_file, strict=True)
1496       except EnvironmentError, err:
1497         raise errors.HypervisorError("Failed to open SPICE password file %s: %s"
1498                                      % (spice_password_file, err))
1499
1500       qmp = QmpConnection(self._InstanceQmpMonitor(instance.name))
1501       qmp.connect()
1502       arguments = {
1503           "protocol": "spice",
1504           "password": spice_pwd,
1505       }
1506       qmp.Execute("set_password", arguments)
1507
1508     for filename in temp_files:
1509       utils.RemoveFile(filename)
1510
1511     # If requested, set CPU affinity and resume instance execution
1512     if cpu_pinning:
1513       self._ExecuteCpuAffinity(instance.name, up_hvp[constants.HV_CPU_MASK])
1514
1515     start_memory = self._InstanceStartupMemory(instance)
1516     if start_memory < instance.beparams[constants.BE_MAXMEM]:
1517       self.BalloonInstanceMemory(instance, start_memory)
1518
1519     if start_kvm_paused:
1520       # To control CPU pinning, ballooning, and vnc/spice passwords
1521       # the VM was started in a frozen state. If freezing was not
1522       # explicitly requested resume the vm status.
1523       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1524
1525   def StartInstance(self, instance, block_devices, startup_paused):
1526     """Start an instance.
1527
1528     """
1529     self._CheckDown(instance.name)
1530     kvm_runtime = self._GenerateKVMRuntime(instance, block_devices,
1531                                            startup_paused)
1532     self._SaveKVMRuntime(instance, kvm_runtime)
1533     self._ExecuteKVMRuntime(instance, kvm_runtime)
1534
1535   def _CallMonitorCommand(self, instance_name, command):
1536     """Invoke a command on the instance monitor.
1537
1538     """
1539     socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" %
1540              (utils.ShellQuote(command),
1541               constants.SOCAT_PATH,
1542               utils.ShellQuote(self._InstanceMonitor(instance_name))))
1543     result = utils.RunCmd(socat)
1544     if result.failed:
1545       msg = ("Failed to send command '%s' to instance %s."
1546              " output: %s, error: %s, fail_reason: %s" %
1547              (command, instance_name,
1548               result.stdout, result.stderr, result.fail_reason))
1549       raise errors.HypervisorError(msg)
1550
1551     return result
1552
1553   @classmethod
1554   def _ParseKVMVersion(cls, text):
1555     """Parse the KVM version from the --help output.
1556
1557     @type text: string
1558     @param text: output of kvm --help
1559     @return: (version, v_maj, v_min, v_rev)
1560     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1561
1562     """
1563     match = cls._VERSION_RE.search(text.splitlines()[0])
1564     if not match:
1565       raise errors.HypervisorError("Unable to get KVM version")
1566
1567     v_all = match.group(0)
1568     v_maj = int(match.group(1))
1569     v_min = int(match.group(2))
1570     if match.group(4):
1571       v_rev = int(match.group(4))
1572     else:
1573       v_rev = 0
1574     return (v_all, v_maj, v_min, v_rev)
1575
1576   @classmethod
1577   def _GetKVMVersion(cls):
1578     """Return the installed KVM version.
1579
1580     @return: (version, v_maj, v_min, v_rev)
1581     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1582
1583     """
1584     result = utils.RunCmd([constants.KVM_PATH, "--help"])
1585     if result.failed:
1586       raise errors.HypervisorError("Unable to get KVM version")
1587     return cls._ParseKVMVersion(result.output)
1588
1589   def StopInstance(self, instance, force=False, retry=False, name=None):
1590     """Stop an instance.
1591
1592     """
1593     if name is not None and not force:
1594       raise errors.HypervisorError("Cannot shutdown cleanly by name only")
1595     if name is None:
1596       name = instance.name
1597       acpi = instance.hvparams[constants.HV_ACPI]
1598     else:
1599       acpi = False
1600     _, pid, alive = self._InstancePidAlive(name)
1601     if pid > 0 and alive:
1602       if force or not acpi:
1603         utils.KillProcess(pid)
1604       else:
1605         self._CallMonitorCommand(name, "system_powerdown")
1606
1607   def CleanupInstance(self, instance_name):
1608     """Cleanup after a stopped instance
1609
1610     """
1611     pidfile, pid, alive = self._InstancePidAlive(instance_name)
1612     if pid > 0 and alive:
1613       raise errors.HypervisorError("Cannot cleanup a live instance")
1614     self._RemoveInstanceRuntimeFiles(pidfile, instance_name)
1615
1616   def RebootInstance(self, instance):
1617     """Reboot an instance.
1618
1619     """
1620     # For some reason if we do a 'send-key ctrl-alt-delete' to the control
1621     # socket the instance will stop, but now power up again. So we'll resort
1622     # to shutdown and restart.
1623     _, _, alive = self._InstancePidAlive(instance.name)
1624     if not alive:
1625       raise errors.HypervisorError("Failed to reboot instance %s:"
1626                                    " not running" % instance.name)
1627     # StopInstance will delete the saved KVM runtime so:
1628     # ...first load it...
1629     kvm_runtime = self._LoadKVMRuntime(instance)
1630     # ...now we can safely call StopInstance...
1631     if not self.StopInstance(instance):
1632       self.StopInstance(instance, force=True)
1633     # ...and finally we can save it again, and execute it...
1634     self._SaveKVMRuntime(instance, kvm_runtime)
1635     self._ExecuteKVMRuntime(instance, kvm_runtime)
1636
1637   def MigrationInfo(self, instance):
1638     """Get instance information to perform a migration.
1639
1640     @type instance: L{objects.Instance}
1641     @param instance: instance to be migrated
1642     @rtype: string
1643     @return: content of the KVM runtime file
1644
1645     """
1646     return self._ReadKVMRuntime(instance.name)
1647
1648   def AcceptInstance(self, instance, info, target):
1649     """Prepare to accept an instance.
1650
1651     @type instance: L{objects.Instance}
1652     @param instance: instance to be accepted
1653     @type info: string
1654     @param info: content of the KVM runtime file on the source node
1655     @type target: string
1656     @param target: target host (usually ip), on this node
1657
1658     """
1659     kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1660     incoming_address = (target, instance.hvparams[constants.HV_MIGRATION_PORT])
1661     self._ExecuteKVMRuntime(instance, kvm_runtime, incoming=incoming_address)
1662
1663   def FinalizeMigrationDst(self, instance, info, success):
1664     """Finalize the instance migration on the target node.
1665
1666     Stop the incoming mode KVM.
1667
1668     @type instance: L{objects.Instance}
1669     @param instance: instance whose migration is being finalized
1670
1671     """
1672     if success:
1673       kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1674       kvm_nics = kvm_runtime[1]
1675
1676       for nic_seq, nic in enumerate(kvm_nics):
1677         if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
1678           # Bridged interfaces have already been configured
1679           continue
1680         try:
1681           tap = utils.ReadFile(self._InstanceNICFile(instance.name, nic_seq))
1682         except EnvironmentError, err:
1683           logging.warning("Failed to find host interface for %s NIC #%d: %s",
1684                           instance.name, nic_seq, str(err))
1685           continue
1686         try:
1687           self._ConfigureNIC(instance, nic_seq, nic, tap)
1688         except errors.HypervisorError, err:
1689           logging.warning(str(err))
1690
1691       self._WriteKVMRuntime(instance.name, info)
1692     else:
1693       self.StopInstance(instance, force=True)
1694
1695   def MigrateInstance(self, instance, target, live):
1696     """Migrate an instance to a target node.
1697
1698     The migration will not be attempted if the instance is not
1699     currently running.
1700
1701     @type instance: L{objects.Instance}
1702     @param instance: the instance to be migrated
1703     @type target: string
1704     @param target: ip address of the target node
1705     @type live: boolean
1706     @param live: perform a live migration
1707
1708     """
1709     instance_name = instance.name
1710     port = instance.hvparams[constants.HV_MIGRATION_PORT]
1711     _, _, alive = self._InstancePidAlive(instance_name)
1712     if not alive:
1713       raise errors.HypervisorError("Instance not running, cannot migrate")
1714
1715     if not live:
1716       self._CallMonitorCommand(instance_name, "stop")
1717
1718     migrate_command = ("migrate_set_speed %dm" %
1719         instance.hvparams[constants.HV_MIGRATION_BANDWIDTH])
1720     self._CallMonitorCommand(instance_name, migrate_command)
1721
1722     migrate_command = ("migrate_set_downtime %dms" %
1723         instance.hvparams[constants.HV_MIGRATION_DOWNTIME])
1724     self._CallMonitorCommand(instance_name, migrate_command)
1725
1726     migrate_command = "migrate -d tcp:%s:%s" % (target, port)
1727     self._CallMonitorCommand(instance_name, migrate_command)
1728
1729   def FinalizeMigrationSource(self, instance, success, live):
1730     """Finalize the instance migration on the source node.
1731
1732     @type instance: L{objects.Instance}
1733     @param instance: the instance that was migrated
1734     @type success: bool
1735     @param success: whether the migration succeeded or not
1736     @type live: bool
1737     @param live: whether the user requested a live migration or not
1738
1739     """
1740     if success:
1741       pidfile, pid, _ = self._InstancePidAlive(instance.name)
1742       utils.KillProcess(pid)
1743       self._RemoveInstanceRuntimeFiles(pidfile, instance.name)
1744     elif live:
1745       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1746
1747   def GetMigrationStatus(self, instance):
1748     """Get the migration status
1749
1750     @type instance: L{objects.Instance}
1751     @param instance: the instance that is being migrated
1752     @rtype: L{objects.MigrationStatus}
1753     @return: the status of the current migration (one of
1754              L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
1755              progress info that can be retrieved from the hypervisor
1756
1757     """
1758     info_command = "info migrate"
1759     for _ in range(self._MIGRATION_INFO_MAX_BAD_ANSWERS):
1760       result = self._CallMonitorCommand(instance.name, info_command)
1761       match = self._MIGRATION_STATUS_RE.search(result.stdout)
1762       if not match:
1763         if not result.stdout:
1764           logging.info("KVM: empty 'info migrate' result")
1765         else:
1766           logging.warning("KVM: unknown 'info migrate' result: %s",
1767                           result.stdout)
1768       else:
1769         status = match.group(1)
1770         if status in constants.HV_KVM_MIGRATION_VALID_STATUSES:
1771           migration_status = objects.MigrationStatus(status=status)
1772           match = self._MIGRATION_PROGRESS_RE.search(result.stdout)
1773           if match:
1774             migration_status.transferred_ram = match.group("transferred")
1775             migration_status.total_ram = match.group("total")
1776
1777           return migration_status
1778
1779         logging.warning("KVM: unknown migration status '%s'", status)
1780
1781       time.sleep(self._MIGRATION_INFO_RETRY_DELAY)
1782
1783     return objects.MigrationStatus(status=constants.HV_MIGRATION_FAILED,
1784                                   info="Too many 'info migrate' broken answers")
1785
1786   def BalloonInstanceMemory(self, instance, mem):
1787     """Balloon an instance memory to a certain value.
1788
1789     @type instance: L{objects.Instance}
1790     @param instance: instance to be accepted
1791     @type mem: int
1792     @param mem: actual memory size to use for instance runtime
1793
1794     """
1795     self._CallMonitorCommand(instance.name, "balloon %d" % mem)
1796
1797   def GetNodeInfo(self):
1798     """Return information about the node.
1799
1800     @return: a dict with the following keys (values in MiB):
1801           - memory_total: the total memory size on the node
1802           - memory_free: the available memory on the node for instances
1803           - memory_dom0: the memory used by the node itself, if available
1804           - hv_version: the hypervisor version in the form (major, minor,
1805                         revision)
1806
1807     """
1808     result = self.GetLinuxNodeInfo()
1809     _, v_major, v_min, v_rev = self._GetKVMVersion()
1810     result[constants.HV_NODEINFO_KEY_VERSION] = (v_major, v_min, v_rev)
1811     return result
1812
1813   @classmethod
1814   def GetInstanceConsole(cls, instance, hvparams, beparams):
1815     """Return a command for connecting to the console of an instance.
1816
1817     """
1818     if hvparams[constants.HV_SERIAL_CONSOLE]:
1819       cmd = [constants.KVM_CONSOLE_WRAPPER,
1820              constants.SOCAT_PATH, utils.ShellQuote(instance.name),
1821              utils.ShellQuote(cls._InstanceMonitor(instance.name)),
1822              "STDIO,%s" % cls._SocatUnixConsoleParams(),
1823              "UNIX-CONNECT:%s" % cls._InstanceSerial(instance.name)]
1824       return objects.InstanceConsole(instance=instance.name,
1825                                      kind=constants.CONS_SSH,
1826                                      host=instance.primary_node,
1827                                      user=constants.GANETI_RUNAS,
1828                                      command=cmd)
1829
1830     vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
1831     if vnc_bind_address and instance.network_port > constants.VNC_BASE_PORT:
1832       display = instance.network_port - constants.VNC_BASE_PORT
1833       return objects.InstanceConsole(instance=instance.name,
1834                                      kind=constants.CONS_VNC,
1835                                      host=vnc_bind_address,
1836                                      port=instance.network_port,
1837                                      display=display)
1838
1839     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1840     if spice_bind:
1841       return objects.InstanceConsole(instance=instance.name,
1842                                      kind=constants.CONS_SPICE,
1843                                      host=spice_bind,
1844                                      port=instance.network_port)
1845
1846     return objects.InstanceConsole(instance=instance.name,
1847                                    kind=constants.CONS_MESSAGE,
1848                                    message=("No serial shell for instance %s" %
1849                                             instance.name))
1850
1851   def Verify(self):
1852     """Verify the hypervisor.
1853
1854     Check that the binary exists.
1855
1856     """
1857     if not os.path.exists(constants.KVM_PATH):
1858       return "The kvm binary ('%s') does not exist." % constants.KVM_PATH
1859     if not os.path.exists(constants.SOCAT_PATH):
1860       return "The socat binary ('%s') does not exist." % constants.SOCAT_PATH
1861
1862   @classmethod
1863   def CheckParameterSyntax(cls, hvparams):
1864     """Check the given parameters for validity.
1865
1866     @type hvparams:  dict
1867     @param hvparams: dictionary with parameter names/value
1868     @raise errors.HypervisorError: when a parameter is not valid
1869
1870     """
1871     super(KVMHypervisor, cls).CheckParameterSyntax(hvparams)
1872
1873     kernel_path = hvparams[constants.HV_KERNEL_PATH]
1874     if kernel_path:
1875       if not hvparams[constants.HV_ROOT_PATH]:
1876         raise errors.HypervisorError("Need a root partition for the instance,"
1877                                      " if a kernel is defined")
1878
1879     if (hvparams[constants.HV_VNC_X509_VERIFY] and
1880         not hvparams[constants.HV_VNC_X509]):
1881       raise errors.HypervisorError("%s must be defined, if %s is" %
1882                                    (constants.HV_VNC_X509,
1883                                     constants.HV_VNC_X509_VERIFY))
1884
1885     boot_order = hvparams[constants.HV_BOOT_ORDER]
1886     if (boot_order == constants.HT_BO_CDROM and
1887         not hvparams[constants.HV_CDROM_IMAGE_PATH]):
1888       raise errors.HypervisorError("Cannot boot from cdrom without an"
1889                                    " ISO path")
1890
1891     security_model = hvparams[constants.HV_SECURITY_MODEL]
1892     if security_model == constants.HT_SM_USER:
1893       if not hvparams[constants.HV_SECURITY_DOMAIN]:
1894         raise errors.HypervisorError("A security domain (user to run kvm as)"
1895                                      " must be specified")
1896     elif (security_model == constants.HT_SM_NONE or
1897           security_model == constants.HT_SM_POOL):
1898       if hvparams[constants.HV_SECURITY_DOMAIN]:
1899         raise errors.HypervisorError("Cannot have a security domain when the"
1900                                      " security model is 'none' or 'pool'")
1901
1902     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1903     spice_ip_version = hvparams[constants.HV_KVM_SPICE_IP_VERSION]
1904     if spice_bind:
1905       if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
1906         # if an IP version is specified, the spice_bind parameter must be an
1907         # IP of that family
1908         if (netutils.IP4Address.IsValid(spice_bind) and
1909             spice_ip_version != constants.IP4_VERSION):
1910           raise errors.HypervisorError("spice: got an IPv4 address (%s), but"
1911                                        " the specified IP version is %s" %
1912                                        (spice_bind, spice_ip_version))
1913
1914         if (netutils.IP6Address.IsValid(spice_bind) and
1915             spice_ip_version != constants.IP6_VERSION):
1916           raise errors.HypervisorError("spice: got an IPv6 address (%s), but"
1917                                        " the specified IP version is %s" %
1918                                        (spice_bind, spice_ip_version))
1919     else:
1920       # All the other SPICE parameters depend on spice_bind being set. Raise an
1921       # error if any of them is set without it.
1922       spice_additional_params = frozenset([
1923         constants.HV_KVM_SPICE_IP_VERSION,
1924         constants.HV_KVM_SPICE_PASSWORD_FILE,
1925         constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR,
1926         constants.HV_KVM_SPICE_JPEG_IMG_COMPR,
1927         constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR,
1928         constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION,
1929         constants.HV_KVM_SPICE_USE_TLS,
1930         ])
1931       for param in spice_additional_params:
1932         if hvparams[param]:
1933           raise errors.HypervisorError("spice: %s requires %s to be set" %
1934                                        (param, constants.HV_KVM_SPICE_BIND))
1935
1936   @classmethod
1937   def ValidateParameters(cls, hvparams):
1938     """Check the given parameters for validity.
1939
1940     @type hvparams:  dict
1941     @param hvparams: dictionary with parameter names/value
1942     @raise errors.HypervisorError: when a parameter is not valid
1943
1944     """
1945     super(KVMHypervisor, cls).ValidateParameters(hvparams)
1946
1947     security_model = hvparams[constants.HV_SECURITY_MODEL]
1948     if security_model == constants.HT_SM_USER:
1949       username = hvparams[constants.HV_SECURITY_DOMAIN]
1950       try:
1951         pwd.getpwnam(username)
1952       except KeyError:
1953         raise errors.HypervisorError("Unknown security domain user %s"
1954                                      % username)
1955
1956     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
1957     if spice_bind:
1958       # only one of VNC and SPICE can be used currently.
1959       if hvparams[constants.HV_VNC_BIND_ADDRESS]:
1960         raise errors.HypervisorError("both SPICE and VNC are configured, but"
1961                                      " only one of them can be used at a"
1962                                      " given time.")
1963
1964       # KVM version should be >= 0.14.0
1965       _, v_major, v_min, _ = cls._GetKVMVersion()
1966       if (v_major, v_min) < (0, 14):
1967         raise errors.HypervisorError("spice is configured, but it is not"
1968                                      " available in versions of KVM < 0.14")
1969
1970       # if spice_bind is not an IP address, it must be a valid interface
1971       bound_to_addr = (netutils.IP4Address.IsValid(spice_bind)
1972                        or netutils.IP6Address.IsValid(spice_bind))
1973       if not bound_to_addr and not netutils.IsValidInterface(spice_bind):
1974         raise errors.HypervisorError("spice: the %s parameter must be either"
1975                                      " a valid IP address or interface name" %
1976                                      constants.HV_KVM_SPICE_BIND)
1977
1978   @classmethod
1979   def PowercycleNode(cls):
1980     """KVM powercycle, just a wrapper over Linux powercycle.
1981
1982     """
1983     cls.LinuxPowercycle()