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

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