Statistics
| Branch: | Tag: | Revision:

root / lib / hypervisor / hv_kvm.py @ 62457f51

History | View | Annotate | Download (71.6 kB)

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()