Source Code for Module ganeti.hypervisor.hv_kvm

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