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 import fdsend
  41 try:
  42   import affinity   # pylint: disable=F0401
  43 except ImportError:
  44   affinity = None
  45
  46 from ganeti import utils
  47 from ganeti import constants
  48 from ganeti import errors
  49 from ganeti import serializer
  50 from ganeti import objects
  51 from ganeti import uidpool
  52 from ganeti import ssconf
  53 from ganeti.hypervisor import hv_base
  54 from ganeti import netutils
  55 from ganeti.utils import wrapper as utils_wrapper
  56
  57
  58 _KVM_NETWORK_SCRIPT = constants.SYSCONFDIR + "/ganeti/kvm-vif-bridge"
  59 _KVM_START_PAUSED_FLAG = "-S"
  60
  61 # TUN/TAP driver constants, taken from <linux/if_tun.h>
  62 # They are architecture-independent and already hardcoded in qemu-kvm source,
  63 # so we can safely include them here.
  64 TUNSETIFF = 0x400454ca
  65 TUNGETIFF = 0x800454d2
  66 TUNGETFEATURES = 0x800454cf
  67 IFF_TAP = 0x0002
  68 IFF_NO_PI = 0x1000
  69 IFF_VNET_HDR = 0x4000
  70
  71
  72 def _ProbeTapVnetHdr(fd):
  73   """Check whether to enable the IFF_VNET_HDR flag.
  74
  75   To do this, _all_ of the following conditions must be met:
  76    1. TUNGETFEATURES ioctl() *must* be implemented
  77    2. TUNGETFEATURES ioctl() result *must* contain the IFF_VNET_HDR flag
  78    3. TUNGETIFF ioctl() *must* be implemented; reading the kernel code in
  79       drivers/net/tun.c there is no way to test this until after the tap device
  80       has been created using TUNSETIFF, and there is no way to change the
  81       IFF_VNET_HDR flag after creating the interface, catch-22! However both
  82       TUNGETIFF and TUNGETFEATURES were introduced in kernel version 2.6.27,
  83       thus we can expect TUNGETIFF to be present if TUNGETFEATURES is.
  84
  85    @type fd: int
  86    @param fd: the file descriptor of /dev/net/tun
  87
  88   """
  89   req = struct.pack("I", 0)
  90   try:
  91     res = fcntl.ioctl(fd, TUNGETFEATURES, req)
  92   except EnvironmentError:
  93     logging.warning("TUNGETFEATURES ioctl() not implemented")
  94     return False
  95
  96   tunflags = struct.unpack("I", res)[0]
  97   if tunflags & IFF_VNET_HDR:
  98     return True
  99   else:
 100     logging.warning("Host does not support IFF_VNET_HDR, not enabling")
 101     return False
 102
 103
 104 def _OpenTap(vnet_hdr=True):
 105   """Open a new tap device and return its file descriptor.
 106
 107   This is intended to be used by a qemu-type hypervisor together with the -net
 108   tap,fd=<fd> command line parameter.
 109
 110   @type vnet_hdr: boolean
 111   @param vnet_hdr: Enable the VNET Header
 112   @return: (ifname, tapfd)
 113   @rtype: tuple
 114
 115   """
 116   try:
 117     tapfd = os.open("/dev/net/tun", os.O_RDWR)
 118   except EnvironmentError:
 119     raise errors.HypervisorError("Failed to open /dev/net/tun")
 120
 121   flags = IFF_TAP | IFF_NO_PI
 122
 123   if vnet_hdr and _ProbeTapVnetHdr(tapfd):
 124     flags |= IFF_VNET_HDR
 125
 126   # The struct ifreq ioctl request (see netdevice(7))
 127   ifr = struct.pack("16sh", "", flags)
 128
 129   try:
 130     res = fcntl.ioctl(tapfd, TUNSETIFF, ifr)
 131   except EnvironmentError:
 132     raise errors.HypervisorError("Failed to allocate a new TAP device")
 133
 134   # Get the interface name from the ioctl
 135   ifname = struct.unpack("16sh", res)[0].strip("\x00")
 136   return (ifname, tapfd)
 137
 138
 139 class QmpMessage:
 140   """QEMU Messaging Protocol (QMP) message.
 141
 142   """
 143   def __init__(self, data):
 144     """Creates a new QMP message based on the passed data.
 145
 146     """
 147     if not isinstance(data, dict):
 148       raise TypeError("QmpMessage must be initialized with a dict")
 149
 150     self.data = data
 151
 152   def __getitem__(self, field_name):
 153     """Get the value of the required field if present, or None.
 154
 155     Overrides the [] operator to provide access to the message data,
 156     returning None if the required item is not in the message
 157     @return: the value of the field_name field, or None if field_name
 158              is not contained in the message
 159
 160     """
 161     return self.data.get(field_name, None)
 162
 163   def __setitem__(self, field_name, field_value):
 164     """Set the value of the required field_name to field_value.
 165
 166     """
 167     self.data[field_name] = field_value
 168
 169   @staticmethod
 170   def BuildFromJsonString(json_string):
 171     """Build a QmpMessage from a JSON encoded string.
 172
 173     @type json_string: str
 174     @param json_string: JSON string representing the message
 175     @rtype: L{QmpMessage}
 176     @return: a L{QmpMessage} built from json_string
 177
 178     """
 179     # Parse the string
 180     data = serializer.LoadJson(json_string)
 181     return QmpMessage(data)
 182
 183   def __str__(self):
 184     # The protocol expects the JSON object to be sent as a single line.
 185     return serializer.DumpJson(self.data)
 186
 187   def __eq__(self, other):
 188     # When comparing two QmpMessages, we are interested in comparing
 189     # their internal representation of the message data
 190     return self.data == other.data
 191
 192
 193 class QmpConnection:
 194   """Connection to the QEMU Monitor using the QEMU Monitor Protocol (QMP).
 195
 196   """
 197   _FIRST_MESSAGE_KEY = "QMP"
 198   _EVENT_KEY = "event"
 199   _ERROR_KEY = "error"
 200   _RETURN_KEY = RETURN_KEY = "return"
 201   _ACTUAL_KEY = ACTUAL_KEY = "actual"
 202   _ERROR_CLASS_KEY = "class"
 203   _ERROR_DATA_KEY = "data"
 204   _ERROR_DESC_KEY = "desc"
 205   _EXECUTE_KEY = "execute"
 206   _ARGUMENTS_KEY = "arguments"
 207   _CAPABILITIES_COMMAND = "qmp_capabilities"
 208   _MESSAGE_END_TOKEN = "\r\n"
 209   _SOCKET_TIMEOUT = 5
 210
 211   def __init__(self, monitor_filename):
 212     """Instantiates the QmpConnection object.
 213
 214     @type monitor_filename: string
 215     @param monitor_filename: the filename of the UNIX raw socket on which the
 216                              QMP monitor is listening
 217
 218     """
 219     self.monitor_filename = monitor_filename
 220     self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 221     # We want to fail if the server doesn't send a complete message
 222     # in a reasonable amount of time
 223     self.sock.settimeout(self._SOCKET_TIMEOUT)
 224     self._connected = False
 225     self._buf = ""
 226
 227   def _check_socket(self):
 228     sock_stat = None
 229     try:
 230       sock_stat = os.stat(self.monitor_filename)
 231     except EnvironmentError, err:
 232       if err.errno == errno.ENOENT:
 233         raise errors.HypervisorError("No qmp socket found")
 234       else:
 235         raise errors.HypervisorError("Error checking qmp socket: %s",
 236                                      utils.ErrnoOrStr(err))
 237     if not stat.S_ISSOCK(sock_stat.st_mode):
 238       raise errors.HypervisorError("Qmp socket is not a socket")
 239
 240   def _check_connection(self):
 241     """Make sure that the connection is established.
 242
 243     """
 244     if not self._connected:
 245       raise errors.ProgrammerError("To use a QmpConnection you need to first"
 246                                    " invoke connect() on it")
 247
 248   def connect(self):
 249     """Connects to the QMP monitor.
 250
 251     Connects to the UNIX socket and makes sure that we can actually send and
 252     receive data to the kvm instance via QMP.
 253
 254     @raise errors.HypervisorError: when there are communication errors
 255     @raise errors.ProgrammerError: when there are data serialization errors
 256
 257     """
 258     if self._connected:
 259       raise errors.ProgrammerError("Cannot connect twice")
 260
 261     self._check_socket()
 262
 263     # Check file existance/stuff
 264     try:
 265       self.sock.connect(self.monitor_filename)
 266     except EnvironmentError:
 267       raise errors.HypervisorError("Can't connect to qmp socket")
 268     self._connected = True
 269
 270     # Check if we receive a correct greeting message from the server
 271     # (As per the QEMU Protocol Specification 0.1 - section 2.2)
 272     greeting = self._Recv()
 273     if not greeting[self._FIRST_MESSAGE_KEY]:
 274       self._connected = False
 275       raise errors.HypervisorError("kvm: qmp communication error (wrong"
 276                                    " server greeting")
 277
 278     # Let's put the monitor in command mode using the qmp_capabilities
 279     # command, or else no command will be executable.
 280     # (As per the QEMU Protocol Specification 0.1 - section 4)
 281     self.Execute(self._CAPABILITIES_COMMAND)
 282
 283   def _ParseMessage(self, buf):
 284     """Extract and parse a QMP message from the given buffer.
 285
 286     Seeks for a QMP message in the given buf. If found, it parses it and
 287     returns it together with the rest of the characters in the buf.
 288     If no message is found, returns None and the whole buffer.
 289
 290     @raise errors.ProgrammerError: when there are data serialization errors
 291
 292     """
 293     message = None
 294     # Check if we got the message end token (CRLF, as per the QEMU Protocol
 295     # Specification 0.1 - Section 2.1.1)
 296     pos = buf.find(self._MESSAGE_END_TOKEN)
 297     if pos >= 0:
 298       try:
 299         message = QmpMessage.BuildFromJsonString(buf[:pos + 1])
 300       except Exception, err:
 301         raise errors.ProgrammerError("QMP data serialization error: %s" % err)
 302       buf = buf[pos + 1:]
 303
 304     return (message, buf)
 305
 306   def _Recv(self):
 307     """Receives a message from QMP and decodes the received JSON object.
 308
 309     @rtype: QmpMessage
 310     @return: the received message
 311     @raise errors.HypervisorError: when there are communication errors
 312     @raise errors.ProgrammerError: when there are data serialization errors
 313
 314     """
 315     self._check_connection()
 316
 317     # Check if there is already a message in the buffer
 318     (message, self._buf) = self._ParseMessage(self._buf)
 319     if message:
 320       return message
 321
 322     recv_buffer = StringIO.StringIO(self._buf)
 323     recv_buffer.seek(len(self._buf))
 324     try:
 325       while True:
 326         data = self.sock.recv(4096)
 327         if not data:
 328           break
 329         recv_buffer.write(data)
 330
 331         (message, self._buf) = self._ParseMessage(recv_buffer.getvalue())
 332         if message:
 333           return message
 334
 335     except socket.timeout, err:
 336       raise errors.HypervisorError("Timeout while receiving a QMP message: "
 337                                    "%s" % (err))
 338     except socket.error, err:
 339       raise errors.HypervisorError("Unable to receive data from KVM using the"
 340                                    " QMP protocol: %s" % err)
 341
 342   def _Send(self, message):
 343     """Encodes and sends a message to KVM using QMP.
 344
 345     @type message: QmpMessage
 346     @param message: message to send to KVM
 347     @raise errors.HypervisorError: when there are communication errors
 348     @raise errors.ProgrammerError: when there are data serialization errors
 349
 350     """
 351     self._check_connection()
 352     try:
 353       message_str = str(message)
 354     except Exception, err:
 355       raise errors.ProgrammerError("QMP data deserialization error: %s" % err)
 356
 357     try:
 358       self.sock.sendall(message_str)
 359     except socket.timeout, err:
 360       raise errors.HypervisorError("Timeout while sending a QMP message: "
 361                                    "%s (%s)" % (err.string, err.errno))
 362     except socket.error, err:
 363       raise errors.HypervisorError("Unable to send data from KVM using the"
 364                                    " QMP protocol: %s" % err)
 365
 366   def Execute(self, command, arguments=None):
 367     """Executes a QMP command and returns the response of the server.
 368
 369     @type command: str
 370     @param command: the command to execute
 371     @type arguments: dict
 372     @param arguments: dictionary of arguments to be passed to the command
 373     @rtype: dict
 374     @return: dictionary representing the received JSON object
 375     @raise errors.HypervisorError: when there are communication errors
 376     @raise errors.ProgrammerError: when there are data serialization errors
 377
 378     """
 379     self._check_connection()
 380     message = QmpMessage({self._EXECUTE_KEY: command})
 381     if arguments:
 382       message[self._ARGUMENTS_KEY] = arguments
 383     self._Send(message)
 384
 385     # Events can occur between the sending of the command and the reception
 386     # of the response, so we need to filter out messages with the event key.
 387     while True:
 388       response = self._Recv()
 389       err = response[self._ERROR_KEY]
 390       if err:
 391         raise errors.HypervisorError("kvm: error executing the %s"
 392                                      " command: %s (%s, %s):" %
 393                                      (command,
 394                                       err[self._ERROR_DESC_KEY],
 395                                       err[self._ERROR_CLASS_KEY],
 396                                       err[self._ERROR_DATA_KEY]))
 397
 398       elif not response[self._EVENT_KEY]:
 399         return response
 400
 401
 402 class KVMHypervisor(hv_base.BaseHypervisor):
 403   """KVM hypervisor interface
 404
 405   """
 406   CAN_MIGRATE = True
 407
 408   _ROOT_DIR = constants.RUN_GANETI_DIR + "/kvm-hypervisor"
 409   _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids
 410   _UIDS_DIR = _ROOT_DIR + "/uid" # contains instances reserved uids
 411   _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets
 412   _CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data
 413   _NICS_DIR = _ROOT_DIR + "/nic" # contains instances nic <-> tap associations
 414   _KEYMAP_DIR = _ROOT_DIR + "/keymap" # contains instances keymaps
 415   # KVM instances with chroot enabled are started in empty chroot directories.
 416   _CHROOT_DIR = _ROOT_DIR + "/chroot" # for empty chroot directories
 417   # After an instance is stopped, its chroot directory is removed.
 418   # If the chroot directory is not empty, it can't be removed.
 419   # A non-empty chroot directory indicates a possible security incident.
 420   # To support forensics, the non-empty chroot directory is quarantined in
 421   # a separate directory, called 'chroot-quarantine'.
 422   _CHROOT_QUARANTINE_DIR = _ROOT_DIR + "/chroot-quarantine"
 423   _DIRS = [_ROOT_DIR, _PIDS_DIR, _UIDS_DIR, _CTRL_DIR, _CONF_DIR, _NICS_DIR,
 424            _CHROOT_DIR, _CHROOT_QUARANTINE_DIR, _KEYMAP_DIR]
 425
 426   PARAMETERS = {
 427     constants.HV_KERNEL_PATH: hv_base.OPT_FILE_CHECK,
 428     constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
 429     constants.HV_ROOT_PATH: hv_base.NO_CHECK,
 430     constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
 431     constants.HV_ACPI: hv_base.NO_CHECK,
 432     constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,
 433     constants.HV_VNC_BIND_ADDRESS:
 434       (False, lambda x: (netutils.IP4Address.IsValid(x) or
 435                          utils.IsNormAbsPath(x)),
 436        "the VNC bind address must be either a valid IP address or an absolute"
 437        " pathname", None, None),
 438     constants.HV_VNC_TLS: hv_base.NO_CHECK,
 439     constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,
 440     constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK,
 441     constants.HV_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
 442     constants.HV_KVM_SPICE_BIND: hv_base.NO_CHECK, # will be checked later
 443     constants.HV_KVM_SPICE_IP_VERSION:
 444       (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or
 445                          x in constants.VALID_IP_VERSIONS),
 446        "the SPICE IP version should be 4 or 6",
 447        None, None),
 448     constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
 449     constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:
 450       hv_base.ParamInSet(False,
 451         constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),
 452     constants.HV_KVM_SPICE_JPEG_IMG_COMPR:
 453       hv_base.ParamInSet(False,
 454         constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 455     constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:
 456       hv_base.ParamInSet(False,
 457         constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
 458     constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:
 459       hv_base.ParamInSet(False,
 460         constants.HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS),
 461     constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,
 462     constants.HV_KVM_SPICE_USE_TLS: hv_base.NO_CHECK,
 463     constants.HV_KVM_SPICE_TLS_CIPHERS: hv_base.NO_CHECK,
 464     constants.HV_KVM_SPICE_USE_VDAGENT: hv_base.NO_CHECK,
 465     constants.HV_KVM_FLOPPY_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 466     constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 467     constants.HV_KVM_CDROM2_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
 468     constants.HV_BOOT_ORDER:
 469       hv_base.ParamInSet(True, constants.HT_KVM_VALID_BO_TYPES),
 470     constants.HV_NIC_TYPE:
 471       hv_base.ParamInSet(True, constants.HT_KVM_VALID_NIC_TYPES),
 472     constants.HV_DISK_TYPE:
 473       hv_base.ParamInSet(True, constants.HT_KVM_VALID_DISK_TYPES),
 474     constants.HV_KVM_CDROM_DISK_TYPE:
 475       hv_base.ParamInSet(False, constants.HT_KVM_VALID_DISK_TYPES),
 476     constants.HV_USB_MOUSE:
 477       hv_base.ParamInSet(False, constants.HT_KVM_VALID_MOUSE_TYPES),
 478     constants.HV_KEYMAP: hv_base.NO_CHECK,
 479     constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
 480     constants.HV_MIGRATION_BANDWIDTH: hv_base.NO_CHECK,
 481     constants.HV_MIGRATION_DOWNTIME: hv_base.NO_CHECK,
 482     constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
 483     constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
 484     constants.HV_DISK_CACHE:
 485       hv_base.ParamInSet(True, constants.HT_VALID_CACHE_TYPES),
 486     constants.HV_SECURITY_MODEL:
 487       hv_base.ParamInSet(True, constants.HT_KVM_VALID_SM_TYPES),
 488     constants.HV_SECURITY_DOMAIN: hv_base.NO_CHECK,
 489     constants.HV_KVM_FLAG:
 490       hv_base.ParamInSet(False, constants.HT_KVM_FLAG_VALUES),
 491     constants.HV_VHOST_NET: hv_base.NO_CHECK,
 492     constants.HV_KVM_USE_CHROOT: hv_base.NO_CHECK,
 493     constants.HV_MEM_PATH: hv_base.OPT_DIR_CHECK,
 494     constants.HV_REBOOT_BEHAVIOR:
 495       hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
 496     constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_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(process_id,
 837           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
1005     #Now we can specify a different device type for CDROM devices.
1006     cdrom_disk_type = hvp[constants.HV_KVM_CDROM_DISK_TYPE]
1007     if not cdrom_disk_type:
1008       cdrom_disk_type = disk_type
1009
1010     iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
1011     if iso_image:
1012       options = ",format=raw,media=cdrom"
1013       # set cdrom 'if' type
1014       if boot_cdrom:
1015         actual_cdrom_type = constants.HT_DISK_IDE
1016       elif cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1017         actual_cdrom_type = "virtio"
1018       else:
1019         actual_cdrom_type = cdrom_disk_type
1020       if_val = ",if=%s" % actual_cdrom_type
1021       # set boot flag, if needed
1022       boot_val = ""
1023       if boot_cdrom:
1024         kvm_cmd.extend(["-boot", "d"])
1025         if needs_boot_flag:
1026           boot_val = ",boot=on"
1027       # and finally build the entire '-drive' value
1028       drive_val = "file=%s%s%s%s" % (iso_image, options, if_val, boot_val)
1029       kvm_cmd.extend(["-drive", drive_val])
1030
1031     iso_image2 = hvp[constants.HV_KVM_CDROM2_IMAGE_PATH]
1032     if iso_image2:
1033       options = ",format=raw,media=cdrom"
1034       if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
1035         if_val = ",if=virtio"
1036       else:
1037         if_val = ",if=%s" % cdrom_disk_type
1038       drive_val = "file=%s%s%s" % (iso_image2, options, if_val)
1039       kvm_cmd.extend(["-drive", drive_val])
1040
1041     floppy_image = hvp[constants.HV_KVM_FLOPPY_IMAGE_PATH]
1042     if floppy_image:
1043       options = ",format=raw,media=disk"
1044       if boot_floppy:
1045         kvm_cmd.extend(["-boot", "a"])
1046         options = "%s,boot=on" % options
1047       if_val = ",if=floppy"
1048       options = "%s%s" % (options, if_val)
1049       drive_val = "file=%s%s" % (floppy_image, options)
1050       kvm_cmd.extend(["-drive", drive_val])
1051
1052     if kernel_path:
1053       kvm_cmd.extend(["-kernel", kernel_path])
1054       initrd_path = hvp[constants.HV_INITRD_PATH]
1055       if initrd_path:
1056         kvm_cmd.extend(["-initrd", initrd_path])
1057       root_append = ["root=%s" % hvp[constants.HV_ROOT_PATH],
1058                      hvp[constants.HV_KERNEL_ARGS]]
1059       if hvp[constants.HV_SERIAL_CONSOLE]:
1060         root_append.append("console=ttyS0,38400")
1061       kvm_cmd.extend(["-append", " ".join(root_append)])
1062
1063     mem_path = hvp[constants.HV_MEM_PATH]
1064     if mem_path:
1065       kvm_cmd.extend(["-mem-path", mem_path, "-mem-prealloc"])
1066
1067     monitor_dev = ("unix:%s,server,nowait" %
1068                    self._InstanceMonitor(instance.name))
1069     kvm_cmd.extend(["-monitor", monitor_dev])
1070     if hvp[constants.HV_SERIAL_CONSOLE]:
1071       serial_dev = ("unix:%s,server,nowait" %
1072                     self._InstanceSerial(instance.name))
1073       kvm_cmd.extend(["-serial", serial_dev])
1074     else:
1075       kvm_cmd.extend(["-serial", "none"])
1076
1077     mouse_type = hvp[constants.HV_USB_MOUSE]
1078     vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
1079     spice_bind = hvp[constants.HV_KVM_SPICE_BIND]
1080     spice_ip_version = None
1081
1082     if mouse_type:
1083       kvm_cmd.extend(["-usb"])
1084       kvm_cmd.extend(["-usbdevice", mouse_type])
1085     elif vnc_bind_address:
1086       kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
1087
1088     if vnc_bind_address:
1089       if netutils.IP4Address.IsValid(vnc_bind_address):
1090         if instance.network_port > constants.VNC_BASE_PORT:
1091           display = instance.network_port - constants.VNC_BASE_PORT
1092           if vnc_bind_address == constants.IP4_ADDRESS_ANY:
1093             vnc_arg = ":%d" % (display)
1094           else:
1095             vnc_arg = "%s:%d" % (vnc_bind_address, display)
1096         else:
1097           logging.error("Network port is not a valid VNC display (%d < %d)."
1098                         " Not starting VNC", instance.network_port,
1099                         constants.VNC_BASE_PORT)
1100           vnc_arg = "none"
1101
1102         # Only allow tls and other option when not binding to a file, for now.
1103         # kvm/qemu gets confused otherwise about the filename to use.
1104         vnc_append = ""
1105         if hvp[constants.HV_VNC_TLS]:
1106           vnc_append = "%s,tls" % vnc_append
1107           if hvp[constants.HV_VNC_X509_VERIFY]:
1108             vnc_append = "%s,x509verify=%s" % (vnc_append,
1109                                                hvp[constants.HV_VNC_X509])
1110           elif hvp[constants.HV_VNC_X509]:
1111             vnc_append = "%s,x509=%s" % (vnc_append,
1112                                          hvp[constants.HV_VNC_X509])
1113         if hvp[constants.HV_VNC_PASSWORD_FILE]:
1114           vnc_append = "%s,password" % vnc_append
1115
1116         vnc_arg = "%s%s" % (vnc_arg, vnc_append)
1117
1118       else:
1119         vnc_arg = "unix:%s/%s.vnc" % (vnc_bind_address, instance.name)
1120
1121       kvm_cmd.extend(["-vnc", vnc_arg])
1122     elif spice_bind:
1123       # FIXME: this is wrong here; the iface ip address differs
1124       # between systems, so it should be done in _ExecuteKVMRuntime
1125       if netutils.IsValidInterface(spice_bind):
1126         # The user specified a network interface, we have to figure out the IP
1127         # address.
1128         addresses = netutils.GetInterfaceIpAddresses(spice_bind)
1129         spice_ip_version = hvp[constants.HV_KVM_SPICE_IP_VERSION]
1130
1131         # if the user specified an IP version and the interface does not
1132         # have that kind of IP addresses, throw an exception
1133         if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
1134           if not addresses[spice_ip_version]:
1135             raise errors.HypervisorError("spice: unable to get an IPv%s address"
1136                                          " for %s" % (spice_ip_version,
1137                                                       spice_bind))
1138
1139         # the user did not specify an IP version, we have to figure it out
1140         elif (addresses[constants.IP4_VERSION] and
1141               addresses[constants.IP6_VERSION]):
1142           # we have both ipv4 and ipv6, let's use the cluster default IP
1143           # version
1144           cluster_family = ssconf.SimpleStore().GetPrimaryIPFamily()
1145           spice_ip_version = \
1146             netutils.IPAddress.GetVersionFromAddressFamily(cluster_family)
1147         elif addresses[constants.IP4_VERSION]:
1148           spice_ip_version = constants.IP4_VERSION
1149         elif addresses[constants.IP6_VERSION]:
1150           spice_ip_version = constants.IP6_VERSION
1151         else:
1152           raise errors.HypervisorError("spice: unable to get an IP address"
1153                                        " for %s" % (spice_bind))
1154
1155         spice_address = addresses[spice_ip_version][0]
1156
1157       else:
1158         # spice_bind is known to be a valid IP address, because
1159         # ValidateParameters checked it.
1160         spice_address = spice_bind
1161
1162       spice_arg = "addr=%s" % spice_address
1163       if hvp[constants.HV_KVM_SPICE_USE_TLS]:
1164         spice_arg = "%s,tls-port=%s,x509-cacert-file=%s" % (spice_arg,
1165             instance.network_port, constants.SPICE_CACERT_FILE)
1166         spice_arg = "%s,x509-key-file=%s,x509-cert-file=%s" % (spice_arg,
1167             constants.SPICE_CERT_FILE, constants.SPICE_CERT_FILE)
1168         tls_ciphers = hvp[constants.HV_KVM_SPICE_TLS_CIPHERS]
1169         if tls_ciphers:
1170           spice_arg = "%s,tls-ciphers=%s" % (spice_arg, tls_ciphers)
1171       else:
1172         spice_arg = "%s,port=%s" % (spice_arg, instance.network_port)
1173
1174       if not hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]:
1175         spice_arg = "%s,disable-ticketing" % spice_arg
1176
1177       if spice_ip_version:
1178         spice_arg = "%s,ipv%s" % (spice_arg, spice_ip_version)
1179
1180       # Image compression options
1181       img_lossless = hvp[constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR]
1182       img_jpeg = hvp[constants.HV_KVM_SPICE_JPEG_IMG_COMPR]
1183       img_zlib_glz = hvp[constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR]
1184       if img_lossless:
1185         spice_arg = "%s,image-compression=%s" % (spice_arg, img_lossless)
1186       if img_jpeg:
1187         spice_arg = "%s,jpeg-wan-compression=%s" % (spice_arg, img_jpeg)
1188       if img_zlib_glz:
1189         spice_arg = "%s,zlib-glz-wan-compression=%s" % (spice_arg, img_zlib_glz)
1190
1191       # Video stream detection
1192       video_streaming = hvp[constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION]
1193       if video_streaming:
1194         spice_arg = "%s,streaming-video=%s" % (spice_arg, video_streaming)
1195
1196       # Audio compression, by default in qemu-kvm it is on
1197       if not hvp[constants.HV_KVM_SPICE_AUDIO_COMPR]:
1198         spice_arg = "%s,playback-compression=off" % spice_arg
1199       if not hvp[constants.HV_KVM_SPICE_USE_VDAGENT]:
1200         spice_arg = "%s,agent-mouse=off" % spice_arg
1201       else:
1202         # Enable the spice agent communication channel between the host and the
1203         # agent.
1204         kvm_cmd.extend(["-device", "virtio-serial-pci"])
1205         kvm_cmd.extend(["-device", "virtserialport,chardev=spicechannel0,"
1206                                                    "name=com.redhat.spice.0"])
1207         kvm_cmd.extend(["-chardev", "spicevmc,id=spicechannel0,name=vdagent"])
1208
1209       logging.info("KVM: SPICE will listen on port %s", instance.network_port)
1210       kvm_cmd.extend(["-spice", spice_arg])
1211
1212       # Tell kvm to use the paravirtualized graphic card, optimized for SPICE
1213       kvm_cmd.extend(["-vga", "qxl"])
1214
1215     else:
1216       kvm_cmd.extend(["-nographic"])
1217
1218     if hvp[constants.HV_USE_LOCALTIME]:
1219       kvm_cmd.extend(["-localtime"])
1220
1221     if hvp[constants.HV_KVM_USE_CHROOT]:
1222       kvm_cmd.extend(["-chroot", self._InstanceChrootDir(instance.name)])
1223
1224     # Save the current instance nics, but defer their expansion as parameters,
1225     # as we'll need to generate executable temp files for them.
1226     kvm_nics = instance.nics
1227     hvparams = hvp
1228
1229     return (kvm_cmd, kvm_nics, hvparams, block_devices)
1230
1231   def _WriteKVMRuntime(self, instance_name, data):
1232     """Write an instance's KVM runtime
1233
1234     """
1235     try:
1236       utils.WriteFile(self._InstanceKVMRuntime(instance_name),
1237                       data=data)
1238     except EnvironmentError, err:
1239       raise errors.HypervisorError("Failed to save KVM runtime file: %s" % err)
1240
1241   def _ReadKVMRuntime(self, instance_name):
1242     """Read an instance's KVM runtime
1243
1244     """
1245     try:
1246       file_content = utils.ReadFile(self._InstanceKVMRuntime(instance_name))
1247     except EnvironmentError, err:
1248       raise errors.HypervisorError("Failed to load KVM runtime file: %s" % err)
1249     return file_content
1250
1251   def _SaveKVMRuntime(self, instance, kvm_runtime):
1252     """Save an instance's KVM runtime
1253
1254     """
1255     kvm_cmd, kvm_nics, hvparams, block_devices = kvm_runtime
1256     serialized_nics = [nic.ToDict() for nic in kvm_nics]
1257     serialized_blockdevs = [(blk.ToDict(), link) for blk,link in block_devices]
1258     serialized_form = serializer.Dump((kvm_cmd, serialized_nics,
1259                                        hvparams, serialized_blockdevs))
1260     self._WriteKVMRuntime(instance.name, serialized_form)
1261
1262   def _LoadKVMRuntime(self, instance, serialized_runtime=None):
1263     """Load an instance's KVM runtime
1264
1265     """
1266     if not serialized_runtime:
1267       serialized_runtime = self._ReadKVMRuntime(instance.name)
1268     loaded_runtime = serializer.Load(serialized_runtime)
1269     kvm_cmd, serialized_nics, hvparams, serialized_blockdevs = loaded_runtime
1270     kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics]
1271     block_devices = [(objects.Disk.FromDict(sdisk), link)
1272                      for sdisk, link in serialized_blockdevs]
1273     return (kvm_cmd, kvm_nics, hvparams, block_devices)
1274
1275   def _RunKVMCmd(self, name, kvm_cmd, tap_fds=None):
1276     """Run the KVM cmd and check for errors
1277
1278     @type name: string
1279     @param name: instance name
1280     @type kvm_cmd: list of strings
1281     @param kvm_cmd: runcmd input for kvm
1282     @type tap_fds: list of int
1283     @param tap_fds: fds of tap devices opened by Ganeti
1284
1285     """
1286     try:
1287       result = utils.RunCmd(kvm_cmd, noclose_fds=tap_fds)
1288     finally:
1289       for fd in tap_fds:
1290         utils_wrapper.CloseFdNoError(fd)
1291
1292     if result.failed:
1293       raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
1294                                    (name, result.fail_reason, result.output))
1295     if not self._InstancePidAlive(name)[2]:
1296       raise errors.HypervisorError("Failed to start instance %s" % name)
1297
1298   def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None):
1299     """Execute a KVM cmd, after completing it with some last minute data.
1300
1301     @type incoming: tuple of strings
1302     @param incoming: (target_host_ip, port)
1303
1304     """
1305     # Small _ExecuteKVMRuntime hv parameters programming howto:
1306     #  - conf_hvp contains the parameters as configured on ganeti. they might
1307     #    have changed since the instance started; only use them if the change
1308     #    won't affect the inside of the instance (which hasn't been rebooted).
1309     #  - up_hvp contains the parameters as they were when the instance was
1310     #    started, plus any new parameter which has been added between ganeti
1311     #    versions: it is paramount that those default to a value which won't
1312     #    affect the inside of the instance as well.
1313     conf_hvp = instance.hvparams
1314     name = instance.name
1315     self._CheckDown(name)
1316     boot_disk = conf_hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
1317
1318     temp_files = []
1319
1320     kvm_cmd, kvm_nics, up_hvp, block_devices = kvm_runtime
1321     up_hvp = objects.FillDict(conf_hvp, up_hvp)
1322
1323     _, v_major, v_min, _ = self._GetKVMVersion()
1324
1325     # We know it's safe to run as a different user upon migration, so we'll use
1326     # the latest conf, from conf_hvp.
1327     security_model = conf_hvp[constants.HV_SECURITY_MODEL]
1328     if security_model == constants.HT_SM_USER:
1329       kvm_cmd.extend(["-runas", conf_hvp[constants.HV_SECURITY_DOMAIN]])
1330
1331     keymap = conf_hvp[constants.HV_KEYMAP]
1332     if keymap:
1333       keymap_path = self._InstanceKeymapFile(name)
1334       # If a keymap file is specified, KVM won't use its internal defaults. By
1335       # first including the "en-us" layout, an error on loading the actual
1336       # layout (e.g. because it can't be found) won't lead to a non-functional
1337       # keyboard. A keyboard with incorrect keys is still better than none.
1338       utils.WriteFile(keymap_path, data="include en-us\ninclude %s\n" % keymap)
1339       kvm_cmd.extend(["-k", keymap_path])
1340
1341     # whether this is an older KVM version that uses the boot=on flag
1342     # on devices
1343     needs_boot_flag = (v_major, v_min) < (0, 14)
1344
1345     disk_type = up_hvp[constants.HV_DISK_TYPE]
1346     if disk_type == constants.HT_DISK_PARAVIRTUAL:
1347       if_val = ",if=virtio"
1348       if (v_major, v_min) >= (0, 12):
1349         disk_model = "virtio-blk-pci"
1350       else:
1351         disk_model = "virtio"
1352     else:
1353       if_val = ",if=%s" % disk_type
1354       disk_model = disk_type
1355     # Cache mode
1356     disk_cache = up_hvp[constants.HV_DISK_CACHE]
1357     if instance.disk_template in constants.DTS_EXT_MIRROR:
1358       if disk_cache != "none":
1359         # TODO: make this a hard error, instead of a silent overwrite
1360         logging.warning("KVM: overriding disk_cache setting '%s' with 'none'"
1361                         " to prevent shared storage corruption on migration",
1362                         disk_cache)
1363       cache_val = ",cache=none"
1364     elif disk_cache != constants.HT_CACHE_DEFAULT:
1365       cache_val = ",cache=%s" % disk_cache
1366     else:
1367       cache_val = ""
1368     for cfdev, dev_path in block_devices:
1369       if cfdev.mode != constants.DISK_RDWR:
1370         raise errors.HypervisorError("Instance has read-only disks which"
1371                                      " are not supported by KVM")
1372       # TODO: handle FD_LOOP and FD_BLKTAP (?)
1373       boot_val = ""
1374       if boot_disk:
1375         kvm_cmd.extend(["-boot", "c"])
1376         boot_disk = False
1377         if needs_boot_flag and disk_type != constants.HT_DISK_IDE:
1378           boot_val = ",boot=on"
1379       drive_val = "file=%s,format=raw%s%s" % \
1380                   (dev_path, boot_val, cache_val)
1381       if cfdev.pci:
1382         #TODO: name id after model
1383         drive_val += (",bus=0,unit=%d,if=none,id=drive%d" %
1384                       (cfdev.pci, cfdev.idx))
1385       else:
1386         drive_val += if_val
1387
1388       kvm_cmd.extend(["-drive", drive_val])
1389
1390       if cfdev.pci:
1391         dev_val = ("%s,bus=pci.0,addr=%s,drive=drive%d,id=virtio-blk-pci.%d" %
1392                    (disk_model, hex(cfdev.pci), cfdev.idx, cfdev.idx))
1393         kvm_cmd.extend(["-device", dev_val])
1394
1395     # We have reasons to believe changing something like the nic driver/type
1396     # upon migration won't exactly fly with the instance kernel, so for nic
1397     # related parameters we'll use up_hvp
1398     tapfds = []
1399     taps = []
1400     if not kvm_nics:
1401       kvm_cmd.extend(["-net", "none"])
1402     else:
1403       vnet_hdr = False
1404       tap_extra = ""
1405       nic_type = up_hvp[constants.HV_NIC_TYPE]
1406       if nic_type == constants.HT_NIC_PARAVIRTUAL:
1407         # From version 0.12.0, kvm uses a new sintax for network configuration.
1408         if (v_major, v_min) >= (0, 12):
1409           nic_model = "virtio-net-pci"
1410           vnet_hdr = True
1411         else:
1412           nic_model = "virtio"
1413
1414         if up_hvp[constants.HV_VHOST_NET]:
1415           # vhost_net is only available from version 0.13.0 or newer
1416           if (v_major, v_min) >= (0, 13):
1417             tap_extra = ",vhost=on"
1418           else:
1419             raise errors.HypervisorError("vhost_net is configured"
1420                                         " but it is not available")
1421       else:
1422         nic_model = nic_type
1423
1424       for nic_seq, nic in enumerate(kvm_nics):
1425         tapname, tapfd = _OpenTap(vnet_hdr)
1426         tapfds.append(tapfd)
1427         taps.append(tapname)
1428         if (v_major, v_min) >= (0, 12):
1429           if nic.pci:
1430             nic_idx = nic.idx
1431           else:
1432             nic_idx = nic_seq
1433           nic_val = ("%s,mac=%s,netdev=netdev%d" %
1434                      (nic_model, nic.mac, nic_idx))
1435           if nic.pci:
1436             nic_val += (",bus=pci.0,addr=%s,id=virtio-net-pci.%d" %
1437                         (hex(nic.pci), nic_idx))
1438           tap_val = "type=tap,id=netdev%d,fd=%d%s" % (nic_idx, tapfd, tap_extra)
1439           kvm_cmd.extend(["-netdev", tap_val, "-device", nic_val])
1440         else:
1441           nic_val = "nic,vlan=%s,macaddr=%s,model=%s" % (nic_seq,
1442                                                          nic.mac, nic_model)
1443           tap_val = "tap,vlan=%s,fd=%d" % (nic_seq, tapfd)
1444           kvm_cmd.extend(["-net", tap_val, "-net", nic_val])
1445
1446     if incoming:
1447       target, port = incoming
1448       kvm_cmd.extend(["-incoming", "tcp:%s:%s" % (target, port)])
1449
1450     # Changing the vnc password doesn't bother the guest that much. At most it
1451     # will surprise people who connect to it. Whether positively or negatively
1452     # it's debatable.
1453     vnc_pwd_file = conf_hvp[constants.HV_VNC_PASSWORD_FILE]
1454     vnc_pwd = None
1455     if vnc_pwd_file:
1456       try:
1457         vnc_pwd = utils.ReadOneLineFile(vnc_pwd_file, strict=True)
1458       except EnvironmentError, err:
1459         raise errors.HypervisorError("Failed to open VNC password file %s: %s"
1460                                      % (vnc_pwd_file, err))
1461
1462     if conf_hvp[constants.HV_KVM_USE_CHROOT]:
1463       utils.EnsureDirs([(self._InstanceChrootDir(name),
1464                          constants.SECURE_DIR_MODE)])
1465
1466     # Automatically enable QMP if version is >= 0.14
1467     if (v_major, v_min) >= (0, 14):
1468       logging.debug("Enabling QMP")
1469       kvm_cmd.extend(["-qmp", "unix:%s,server,nowait" %
1470                     self._InstanceQmpMonitor(instance.name)])
1471
1472     # Configure the network now for starting instances and bridged interfaces,
1473     # during FinalizeMigration for incoming instances' routed interfaces
1474     for nic_seq, nic in enumerate(kvm_nics):
1475       if (incoming and
1476           nic.nicparams[constants.NIC_MODE] != constants.NIC_MODE_BRIDGED):
1477         continue
1478       self._ConfigureNIC(instance, nic_seq, nic, taps[nic_seq])
1479
1480     # CPU affinity requires kvm to start paused, so we set this flag if the
1481     # instance is not already paused and if we are not going to accept a
1482     # migrating instance. In the latter case, pausing is not needed.
1483     start_kvm_paused = not (_KVM_START_PAUSED_FLAG in kvm_cmd) and not incoming
1484     if start_kvm_paused:
1485       kvm_cmd.extend([_KVM_START_PAUSED_FLAG])
1486
1487     # Note: CPU pinning is using up_hvp since changes take effect
1488     # during instance startup anyway, and to avoid problems when soft
1489     # rebooting the instance.
1490     cpu_pinning = False
1491     if up_hvp.get(constants.HV_CPU_MASK, None):
1492       cpu_pinning = True
1493
1494     if security_model == constants.HT_SM_POOL:
1495       ss = ssconf.SimpleStore()
1496       uid_pool = uidpool.ParseUidPool(ss.GetUidPool(), separator="\n")
1497       all_uids = set(uidpool.ExpandUidPool(uid_pool))
1498       uid = uidpool.RequestUnusedUid(all_uids)
1499       try:
1500         username = pwd.getpwuid(uid.GetUid()).pw_name
1501         kvm_cmd.extend(["-runas", username])
1502         self._RunKVMCmd(name, kvm_cmd, tapfds)
1503       except:
1504         uidpool.ReleaseUid(uid)
1505         raise
1506       else:
1507         uid.Unlock()
1508         utils.WriteFile(self._InstanceUidFile(name), data=uid.AsStr())
1509     else:
1510       self._RunKVMCmd(name, kvm_cmd, tapfds)
1511
1512     utils.EnsureDirs([(self._InstanceNICDir(instance.name),
1513                      constants.RUN_DIRS_MODE)])
1514     for nic_seq, tap in enumerate(taps):
1515       utils.WriteFile(self._InstanceNICFile(instance.name, nic_seq),
1516                       data=tap)
1517
1518     if vnc_pwd:
1519       change_cmd = "change vnc password %s" % vnc_pwd
1520       self._CallMonitorCommand(instance.name, change_cmd)
1521
1522     # Setting SPICE password. We are not vulnerable to malicious passwordless
1523     # connection attempts because SPICE by default does not allow connections
1524     # if neither a password nor the "disable_ticketing" options are specified.
1525     # As soon as we send the password via QMP, that password is a valid ticket
1526     # for connection.
1527     spice_password_file = conf_hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]
1528     if spice_password_file:
1529       spice_pwd = ""
1530       try:
1531         spice_pwd = utils.ReadOneLineFile(spice_password_file, strict=True)
1532       except EnvironmentError, err:
1533         raise errors.HypervisorError("Failed to open SPICE password file %s: %s"
1534                                      % (spice_password_file, err))
1535
1536       qmp = QmpConnection(self._InstanceQmpMonitor(instance.name))
1537       qmp.connect()
1538       arguments = {
1539           "protocol": "spice",
1540           "password": spice_pwd,
1541       }
1542       qmp.Execute("set_password", arguments)
1543
1544     for filename in temp_files:
1545       utils.RemoveFile(filename)
1546
1547     # If requested, set CPU affinity and resume instance execution
1548     if cpu_pinning:
1549       self._ExecuteCpuAffinity(instance.name, up_hvp[constants.HV_CPU_MASK])
1550
1551     start_memory = self._InstanceStartupMemory(instance)
1552     if start_memory < instance.beparams[constants.BE_MAXMEM]:
1553       self.BalloonInstanceMemory(instance, start_memory)
1554
1555     if start_kvm_paused:
1556       # To control CPU pinning, ballooning, and vnc/spice passwords
1557       # the VM was started in a frozen state. If freezing was not
1558       # explicitly requested resume the vm status.
1559       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1560
1561   def StartInstance(self, instance, block_devices, startup_paused):
1562     """Start an instance.
1563
1564     """
1565     self._CheckDown(instance.name)
1566     kvm_runtime = self._GenerateKVMRuntime(instance, block_devices,
1567                                            startup_paused)
1568     self._SaveKVMRuntime(instance, kvm_runtime)
1569     self._ExecuteKVMRuntime(instance, kvm_runtime)
1570
1571   def _CallMonitorCommand(self, instance_name, command):
1572     """Invoke a command on the instance monitor.
1573
1574     """
1575     socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" %
1576              (utils.ShellQuote(command),
1577               constants.SOCAT_PATH,
1578               utils.ShellQuote(self._InstanceMonitor(instance_name))))
1579     result = utils.RunCmd(socat)
1580     if result.failed:
1581       msg = ("Failed to send command '%s' to instance %s."
1582              " output: %s, error: %s, fail_reason: %s" %
1583              (command, instance_name,
1584               result.stdout, result.stderr, result.fail_reason))
1585       raise errors.HypervisorError(msg)
1586
1587     return result
1588
1589   def HotAddDisk(self, instance, disk, dev_path, seq):
1590     """Hotadd new disk to the VM
1591
1592     """
1593     if not self._InstancePidAlive(instance.name)[2]:
1594       logging.info("Cannot hotplug. Instance %s not alive" % instance.name)
1595       return disk.ToDict()
1596
1597     _, v_major, v_min, _ = self._GetKVMVersion()
1598     if (v_major, v_min) >= (1, 0) and disk.pci:
1599       idx = disk.idx
1600       command = ("drive_add dummy file=%s,if=none,id=drive%d,format=raw" %
1601                  (dev_path, idx))
1602
1603       logging.info("%s" % command)
1604       output = self._CallMonitorCommand(instance.name, command)
1605
1606       command = ("device_add virtio-blk-pci,bus=pci.0,addr=%s,"
1607                  "drive=drive%d,id=virtio-blk-pci.%d"
1608                  % (hex(disk.pci), idx, idx))
1609       logging.info("%s" % command)
1610       output = self._CallMonitorCommand(instance.name, command)
1611       for line in output.stdout.splitlines():
1612         logging.info("%s" % line)
1613
1614       (kvm_cmd, kvm_nics,
1615        hvparams, block_devices) = self._LoadKVMRuntime(instance)
1616       block_devices.append((disk, dev_path))
1617       new_kvm_runtime = (kvm_cmd, kvm_nics, hvparams, block_devices)
1618       self._SaveKVMRuntime(instance, new_kvm_runtime)
1619
1620     return disk.ToDict()
1621
1622   def HotDelDisk(self, instance, disk, seq):
1623     """Hotdel disk to the VM
1624
1625     """
1626     if not self._InstancePidAlive(instance.name)[2]:
1627       logging.info("Cannot hotplug. Instance %s not alive" % instance.name)
1628       return disk.ToDict()
1629
1630     _, v_major, v_min, _ = self._GetKVMVersion()
1631     if (v_major, v_min) >= (1, 0) and disk.pci:
1632       idx = disk.idx
1633
1634       command = "device_del virtio-blk-pci.%d" % idx
1635       logging.info("%s" % command)
1636       output = self._CallMonitorCommand(instance.name, command)
1637       for line in output.stdout.splitlines():
1638         logging.info("%s" % line)
1639
1640       command = "drive_del drive%d" % idx
1641       logging.info("%s" % command)
1642       #output = self._CallMonitorCommand(instance.name, command)
1643       #for line in output.stdout.splitlines():
1644       #  logging.info("%s" % line)
1645
1646       (kvm_cmd, kvm_nics,
1647        hvparams, block_devices) = self._LoadKVMRuntime(instance)
1648       rem  = [(d, p) for d, p in block_devices
1649                      if d.idx is not None and d.idx == idx]
1650       try:
1651         block_devices.remove(rem[0])
1652       except (ValueError, IndexError):
1653         logging.info("Disk with %d idx disappeared from runtime file", idx)
1654       new_kvm_runtime = (kvm_cmd, kvm_nics, hvparams, block_devices)
1655       self._SaveKVMRuntime(instance, new_kvm_runtime)
1656
1657     return disk.ToDict()
1658
1659   def HotAddNic(self, instance, nic, seq):
1660     """Hotadd new nic to the VM
1661
1662     """
1663     if not self._InstancePidAlive(instance.name)[2]:
1664       logging.info("Cannot hotplug. Instance %s not alive" % instance.name)
1665       return nic.ToDict()
1666
1667     _, v_major, v_min, _ = self._GetKVMVersion()
1668     if (v_major, v_min) >= (1, 0) and nic.pci:
1669       mac = nic.mac
1670       idx = nic.idx
1671
1672       (tap, fd) = _OpenTap()
1673       logging.info("%s %d", tap, fd)
1674
1675       self._PassTapFd(instance, fd, nic)
1676
1677       command = ("netdev_add tap,id=netdev%d,fd=netdev%d"
1678                  % (idx, idx))
1679       logging.info("%s" % command)
1680       output = self._CallMonitorCommand(instance.name, command)
1681       for line in output.stdout.splitlines():
1682         logging.info("%s" % line)
1683
1684       command = ("device_add virtio-net-pci,bus=pci.0,addr=%s,mac=%s,"
1685                  "netdev=netdev%d,id=virtio-net-pci.%d"
1686                  % (hex(nic.pci), mac, idx, idx))
1687       logging.info("%s" % command)
1688       output = self._CallMonitorCommand(instance.name, command)
1689       for line in output.stdout.splitlines():
1690         logging.info("%s" % line)
1691
1692       self._ConfigureNIC(instance, seq, nic, tap)
1693
1694       (kvm_cmd, kvm_nics,
1695        hvparams, block_devices) = self._LoadKVMRuntime(instance)
1696       kvm_nics.append(nic)
1697       new_kvm_runtime = (kvm_cmd, kvm_nics, hvparams, block_devices)
1698       self._SaveKVMRuntime(instance, new_kvm_runtime)
1699
1700     return nic.ToDict()
1701
1702   def HotDelNic(self, instance, nic, seq):
1703     """Hotadd new nic to the VM
1704
1705     """
1706     if not self._InstancePidAlive(instance.name)[2]:
1707       logging.info("Cannot hotplug. Instance %s not alive" % instance.name)
1708       return nic.ToDict()
1709
1710     _, v_major, v_min, _ = self._GetKVMVersion()
1711     if (v_major, v_min) >= (1, 0) and nic.pci:
1712       mac = nic.mac
1713       idx = nic.idx
1714
1715       command = "device_del virtio-net-pci.%d" % idx
1716       logging.info("%s" % command)
1717       output = self._CallMonitorCommand(instance.name, command)
1718       for line in output.stdout.splitlines():
1719         logging.info("%s" % line)
1720
1721       command = "netdev_del netdev%d" % idx
1722       logging.info("%s" % command)
1723       output = self._CallMonitorCommand(instance.name, command)
1724       for line in output.stdout.splitlines():
1725         logging.info("%s" % line)
1726
1727       (kvm_cmd, kvm_nics,
1728        hvparams, block_devices) = self._LoadKVMRuntime(instance)
1729       rem  = [n for n in kvm_nics if n.idx is not None and n.idx == nic.idx]
1730       try:
1731         kvm_nics.remove(rem[0])
1732       except (ValueError, IndexError):
1733         logging.info("NIC with %d idx disappeared from runtime file", nic.idx)
1734       new_kvm_runtime = (kvm_cmd, kvm_nics, hvparams, block_devices)
1735       self._SaveKVMRuntime(instance, new_kvm_runtime)
1736
1737     return nic.ToDict()
1738
1739   def _PassTapFd(self, instance, fd, nic):
1740     monsock = utils.ShellQuote(self._InstanceMonitor(instance.name))
1741     s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
1742     s.connect(monsock)
1743     idx = nic.idx
1744     command = "getfd netdev%d\n" % idx
1745     fds = [fd]
1746     logging.info("%s", fds)
1747     fdsend.sendfds(s, command, fds = fds)
1748     s.close()
1749
1750   @classmethod
1751   def _ParseKVMVersion(cls, text):
1752     """Parse the KVM version from the --help output.
1753
1754     @type text: string
1755     @param text: output of kvm --help
1756     @return: (version, v_maj, v_min, v_rev)
1757     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1758
1759     """
1760     match = cls._VERSION_RE.search(text.splitlines()[0])
1761     if not match:
1762       raise errors.HypervisorError("Unable to get KVM version")
1763
1764     v_all = match.group(0)
1765     v_maj = int(match.group(1))
1766     v_min = int(match.group(2))
1767     if match.group(4):
1768       v_rev = int(match.group(4))
1769     else:
1770       v_rev = 0
1771     return (v_all, v_maj, v_min, v_rev)
1772
1773   @classmethod
1774   def _GetKVMVersion(cls):
1775     """Return the installed KVM version.
1776
1777     @return: (version, v_maj, v_min, v_rev)
1778     @raise errors.HypervisorError: when the KVM version cannot be retrieved
1779
1780     """
1781     result = utils.RunCmd([constants.KVM_PATH, "--help"])
1782     if result.failed:
1783       raise errors.HypervisorError("Unable to get KVM version")
1784     return cls._ParseKVMVersion(result.output)
1785
1786   def StopInstance(self, instance, force=False, retry=False, name=None):
1787     """Stop an instance.
1788
1789     """
1790     if name is not None and not force:
1791       raise errors.HypervisorError("Cannot shutdown cleanly by name only")
1792     if name is None:
1793       name = instance.name
1794       acpi = instance.hvparams[constants.HV_ACPI]
1795     else:
1796       acpi = False
1797     _, pid, alive = self._InstancePidAlive(name)
1798     if pid > 0 and alive:
1799       if force or not acpi:
1800         utils.KillProcess(pid)
1801       else:
1802         self._CallMonitorCommand(name, "system_powerdown")
1803
1804   def CleanupInstance(self, instance_name):
1805     """Cleanup after a stopped instance
1806
1807     """
1808     pidfile, pid, alive = self._InstancePidAlive(instance_name)
1809     if pid > 0 and alive:
1810       raise errors.HypervisorError("Cannot cleanup a live instance")
1811     self._RemoveInstanceRuntimeFiles(pidfile, instance_name)
1812
1813   def RebootInstance(self, instance):
1814     """Reboot an instance.
1815
1816     """
1817     # For some reason if we do a 'send-key ctrl-alt-delete' to the control
1818     # socket the instance will stop, but now power up again. So we'll resort
1819     # to shutdown and restart.
1820     _, _, alive = self._InstancePidAlive(instance.name)
1821     if not alive:
1822       raise errors.HypervisorError("Failed to reboot instance %s:"
1823                                    " not running" % instance.name)
1824     # StopInstance will delete the saved KVM runtime so:
1825     # ...first load it...
1826     kvm_runtime = self._LoadKVMRuntime(instance)
1827     # ...now we can safely call StopInstance...
1828     if not self.StopInstance(instance):
1829       self.StopInstance(instance, force=True)
1830     # ...and finally we can save it again, and execute it...
1831     self._SaveKVMRuntime(instance, kvm_runtime)
1832     self._ExecuteKVMRuntime(instance, kvm_runtime)
1833
1834   def MigrationInfo(self, instance):
1835     """Get instance information to perform a migration.
1836
1837     @type instance: L{objects.Instance}
1838     @param instance: instance to be migrated
1839     @rtype: string
1840     @return: content of the KVM runtime file
1841
1842     """
1843     return self._ReadKVMRuntime(instance.name)
1844
1845   def AcceptInstance(self, instance, info, target):
1846     """Prepare to accept an instance.
1847
1848     @type instance: L{objects.Instance}
1849     @param instance: instance to be accepted
1850     @type info: string
1851     @param info: content of the KVM runtime file on the source node
1852     @type target: string
1853     @param target: target host (usually ip), on this node
1854
1855     """
1856     kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1857     incoming_address = (target, instance.hvparams[constants.HV_MIGRATION_PORT])
1858     self._ExecuteKVMRuntime(instance, kvm_runtime, incoming=incoming_address)
1859
1860   def FinalizeMigrationDst(self, instance, info, success):
1861     """Finalize the instance migration on the target node.
1862
1863     Stop the incoming mode KVM.
1864
1865     @type instance: L{objects.Instance}
1866     @param instance: instance whose migration is being finalized
1867
1868     """
1869     if success:
1870       kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
1871       kvm_nics = kvm_runtime[1]
1872
1873       for nic_seq, nic in enumerate(kvm_nics):
1874         if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
1875           # Bridged interfaces have already been configured
1876           continue
1877         try:
1878           tap = utils.ReadFile(self._InstanceNICFile(instance.name, nic_seq))
1879         except EnvironmentError, err:
1880           logging.warning("Failed to find host interface for %s NIC #%d: %s",
1881                           instance.name, nic_seq, str(err))
1882           continue
1883         try:
1884           self._ConfigureNIC(instance, nic_seq, nic, tap)
1885         except errors.HypervisorError, err:
1886           logging.warning(str(err))
1887
1888       self._WriteKVMRuntime(instance.name, info)
1889     else:
1890       self.StopInstance(instance, force=True)
1891
1892   def MigrateInstance(self, instance, target, live):
1893     """Migrate an instance to a target node.
1894
1895     The migration will not be attempted if the instance is not
1896     currently running.
1897
1898     @type instance: L{objects.Instance}
1899     @param instance: the instance to be migrated
1900     @type target: string
1901     @param target: ip address of the target node
1902     @type live: boolean
1903     @param live: perform a live migration
1904
1905     """
1906     instance_name = instance.name
1907     port = instance.hvparams[constants.HV_MIGRATION_PORT]
1908     _, _, alive = self._InstancePidAlive(instance_name)
1909     if not alive:
1910       raise errors.HypervisorError("Instance not running, cannot migrate")
1911
1912     if not live:
1913       self._CallMonitorCommand(instance_name, "stop")
1914
1915     migrate_command = ("migrate_set_speed %dm" %
1916         instance.hvparams[constants.HV_MIGRATION_BANDWIDTH])
1917     self._CallMonitorCommand(instance_name, migrate_command)
1918
1919     migrate_command = ("migrate_set_downtime %dms" %
1920         instance.hvparams[constants.HV_MIGRATION_DOWNTIME])
1921     self._CallMonitorCommand(instance_name, migrate_command)
1922
1923     migrate_command = "migrate -d tcp:%s:%s" % (target, port)
1924     self._CallMonitorCommand(instance_name, migrate_command)
1925
1926   def FinalizeMigrationSource(self, instance, success, live):
1927     """Finalize the instance migration on the source node.
1928
1929     @type instance: L{objects.Instance}
1930     @param instance: the instance that was migrated
1931     @type success: bool
1932     @param success: whether the migration succeeded or not
1933     @type live: bool
1934     @param live: whether the user requested a live migration or not
1935
1936     """
1937     if success:
1938       pidfile, pid, _ = self._InstancePidAlive(instance.name)
1939       utils.KillProcess(pid)
1940       self._RemoveInstanceRuntimeFiles(pidfile, instance.name)
1941     elif live:
1942       self._CallMonitorCommand(instance.name, self._CONT_CMD)
1943
1944   def GetMigrationStatus(self, instance):
1945     """Get the migration status
1946
1947     @type instance: L{objects.Instance}
1948     @param instance: the instance that is being migrated
1949     @rtype: L{objects.MigrationStatus}
1950     @return: the status of the current migration (one of
1951              L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
1952              progress info that can be retrieved from the hypervisor
1953
1954     """
1955     info_command = "info migrate"
1956     for _ in range(self._MIGRATION_INFO_MAX_BAD_ANSWERS):
1957       result = self._CallMonitorCommand(instance.name, info_command)
1958       match = self._MIGRATION_STATUS_RE.search(result.stdout)
1959       if not match:
1960         if not result.stdout:
1961           logging.info("KVM: empty 'info migrate' result")
1962         else:
1963           logging.warning("KVM: unknown 'info migrate' result: %s",
1964                           result.stdout)
1965       else:
1966         status = match.group(1)
1967         if status in constants.HV_KVM_MIGRATION_VALID_STATUSES:
1968           migration_status = objects.MigrationStatus(status=status)
1969           match = self._MIGRATION_PROGRESS_RE.search(result.stdout)
1970           if match:
1971             migration_status.transferred_ram = match.group("transferred")
1972             migration_status.total_ram = match.group("total")
1973
1974           return migration_status
1975
1976         logging.warning("KVM: unknown migration status '%s'", status)
1977
1978       time.sleep(self._MIGRATION_INFO_RETRY_DELAY)
1979
1980     return objects.MigrationStatus(status=constants.HV_MIGRATION_FAILED,
1981                                   info="Too many 'info migrate' broken answers")
1982
1983   def BalloonInstanceMemory(self, instance, mem):
1984     """Balloon an instance memory to a certain value.
1985
1986     @type instance: L{objects.Instance}
1987     @param instance: instance to be accepted
1988     @type mem: int
1989     @param mem: actual memory size to use for instance runtime
1990
1991     """
1992     self._CallMonitorCommand(instance.name, "balloon %d" % mem)
1993
1994   def GetNodeInfo(self):
1995     """Return information about the node.
1996
1997     @return: a dict with the following keys (values in MiB):
1998           - memory_total: the total memory size on the node
1999           - memory_free: the available memory on the node for instances
2000           - memory_dom0: the memory used by the node itself, if available
2001           - hv_version: the hypervisor version in the form (major, minor,
2002                         revision)
2003
2004     """
2005     result = self.GetLinuxNodeInfo()
2006     _, v_major, v_min, v_rev = self._GetKVMVersion()
2007     result[constants.HV_NODEINFO_KEY_VERSION] = (v_major, v_min, v_rev)
2008     return result
2009
2010   @classmethod
2011   def GetInstanceConsole(cls, instance, hvparams, beparams):
2012     """Return a command for connecting to the console of an instance.
2013
2014     """
2015     if hvparams[constants.HV_SERIAL_CONSOLE]:
2016       cmd = [constants.KVM_CONSOLE_WRAPPER,
2017              constants.SOCAT_PATH, utils.ShellQuote(instance.name),
2018              utils.ShellQuote(cls._InstanceMonitor(instance.name)),
2019              "STDIO,%s" % cls._SocatUnixConsoleParams(),
2020              "UNIX-CONNECT:%s" % cls._InstanceSerial(instance.name)]
2021       return objects.InstanceConsole(instance=instance.name,
2022                                      kind=constants.CONS_SSH,
2023                                      host=instance.primary_node,
2024                                      user=constants.GANETI_RUNAS,
2025                                      command=cmd)
2026
2027     vnc_bind_address = hvparams[constants.HV_VNC_BIND_ADDRESS]
2028     if vnc_bind_address and instance.network_port > constants.VNC_BASE_PORT:
2029       display = instance.network_port - constants.VNC_BASE_PORT
2030       return objects.InstanceConsole(instance=instance.name,
2031                                      kind=constants.CONS_VNC,
2032                                      host=vnc_bind_address,
2033                                      port=instance.network_port,
2034                                      display=display)
2035
2036     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
2037     if spice_bind:
2038       return objects.InstanceConsole(instance=instance.name,
2039                                      kind=constants.CONS_SPICE,
2040                                      host=spice_bind,
2041                                      port=instance.network_port)
2042
2043     return objects.InstanceConsole(instance=instance.name,
2044                                    kind=constants.CONS_MESSAGE,
2045                                    message=("No serial shell for instance %s" %
2046                                             instance.name))
2047
2048   def Verify(self):
2049     """Verify the hypervisor.
2050
2051     Check that the binary exists.
2052
2053     """
2054     if not os.path.exists(constants.KVM_PATH):
2055       return "The kvm binary ('%s') does not exist." % constants.KVM_PATH
2056     if not os.path.exists(constants.SOCAT_PATH):
2057       return "The socat binary ('%s') does not exist." % constants.SOCAT_PATH
2058
2059   @classmethod
2060   def CheckParameterSyntax(cls, hvparams):
2061     """Check the given parameters for validity.
2062
2063     @type hvparams:  dict
2064     @param hvparams: dictionary with parameter names/value
2065     @raise errors.HypervisorError: when a parameter is not valid
2066
2067     """
2068     super(KVMHypervisor, cls).CheckParameterSyntax(hvparams)
2069
2070     kernel_path = hvparams[constants.HV_KERNEL_PATH]
2071     if kernel_path:
2072       if not hvparams[constants.HV_ROOT_PATH]:
2073         raise errors.HypervisorError("Need a root partition for the instance,"
2074                                      " if a kernel is defined")
2075
2076     if (hvparams[constants.HV_VNC_X509_VERIFY] and
2077         not hvparams[constants.HV_VNC_X509]):
2078       raise errors.HypervisorError("%s must be defined, if %s is" %
2079                                    (constants.HV_VNC_X509,
2080                                     constants.HV_VNC_X509_VERIFY))
2081
2082     boot_order = hvparams[constants.HV_BOOT_ORDER]
2083     if (boot_order == constants.HT_BO_CDROM and
2084         not hvparams[constants.HV_CDROM_IMAGE_PATH]):
2085       raise errors.HypervisorError("Cannot boot from cdrom without an"
2086                                    " ISO path")
2087
2088     security_model = hvparams[constants.HV_SECURITY_MODEL]
2089     if security_model == constants.HT_SM_USER:
2090       if not hvparams[constants.HV_SECURITY_DOMAIN]:
2091         raise errors.HypervisorError("A security domain (user to run kvm as)"
2092                                      " must be specified")
2093     elif (security_model == constants.HT_SM_NONE or
2094           security_model == constants.HT_SM_POOL):
2095       if hvparams[constants.HV_SECURITY_DOMAIN]:
2096         raise errors.HypervisorError("Cannot have a security domain when the"
2097                                      " security model is 'none' or 'pool'")
2098
2099     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
2100     spice_ip_version = hvparams[constants.HV_KVM_SPICE_IP_VERSION]
2101     if spice_bind:
2102       if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
2103         # if an IP version is specified, the spice_bind parameter must be an
2104         # IP of that family
2105         if (netutils.IP4Address.IsValid(spice_bind) and
2106             spice_ip_version != constants.IP4_VERSION):
2107           raise errors.HypervisorError("spice: got an IPv4 address (%s), but"
2108                                        " the specified IP version is %s" %
2109                                        (spice_bind, spice_ip_version))
2110
2111         if (netutils.IP6Address.IsValid(spice_bind) and
2112             spice_ip_version != constants.IP6_VERSION):
2113           raise errors.HypervisorError("spice: got an IPv6 address (%s), but"
2114                                        " the specified IP version is %s" %
2115                                        (spice_bind, spice_ip_version))
2116     else:
2117       # All the other SPICE parameters depend on spice_bind being set. Raise an
2118       # error if any of them is set without it.
2119       spice_additional_params = frozenset([
2120         constants.HV_KVM_SPICE_IP_VERSION,
2121         constants.HV_KVM_SPICE_PASSWORD_FILE,
2122         constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR,
2123         constants.HV_KVM_SPICE_JPEG_IMG_COMPR,
2124         constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR,
2125         constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION,
2126         constants.HV_KVM_SPICE_USE_TLS,
2127         ])
2128       for param in spice_additional_params:
2129         if hvparams[param]:
2130           raise errors.HypervisorError("spice: %s requires %s to be set" %
2131                                        (param, constants.HV_KVM_SPICE_BIND))
2132
2133   @classmethod
2134   def ValidateParameters(cls, hvparams):
2135     """Check the given parameters for validity.
2136
2137     @type hvparams:  dict
2138     @param hvparams: dictionary with parameter names/value
2139     @raise errors.HypervisorError: when a parameter is not valid
2140
2141     """
2142     super(KVMHypervisor, cls).ValidateParameters(hvparams)
2143
2144     security_model = hvparams[constants.HV_SECURITY_MODEL]
2145     if security_model == constants.HT_SM_USER:
2146       username = hvparams[constants.HV_SECURITY_DOMAIN]
2147       try:
2148         pwd.getpwnam(username)
2149       except KeyError:
2150         raise errors.HypervisorError("Unknown security domain user %s"
2151                                      % username)
2152
2153     spice_bind = hvparams[constants.HV_KVM_SPICE_BIND]
2154     if spice_bind:
2155       # only one of VNC and SPICE can be used currently.
2156       if hvparams[constants.HV_VNC_BIND_ADDRESS]:
2157         raise errors.HypervisorError("both SPICE and VNC are configured, but"
2158                                      " only one of them can be used at a"
2159                                      " given time.")
2160
2161       # KVM version should be >= 0.14.0
2162       _, v_major, v_min, _ = cls._GetKVMVersion()
2163       if (v_major, v_min) < (0, 14):
2164         raise errors.HypervisorError("spice is configured, but it is not"
2165                                      " available in versions of KVM < 0.14")
2166
2167       # if spice_bind is not an IP address, it must be a valid interface
2168       bound_to_addr = (netutils.IP4Address.IsValid(spice_bind)
2169                        or netutils.IP6Address.IsValid(spice_bind))
2170       if not bound_to_addr and not netutils.IsValidInterface(spice_bind):
2171         raise errors.HypervisorError("spice: the %s parameter must be either"
2172                                      " a valid IP address or interface name" %
2173                                      constants.HV_KVM_SPICE_BIND)
2174
2175   @classmethod
2176   def PowercycleNode(cls):
2177     """KVM powercycle, just a wrapper over Linux powercycle.
2178
2179     """
2180     cls.LinuxPowercycle()