hv_kvm.py 76.3 KB
Newer Older
Guido Trotter's avatar
Guido Trotter committed
1
2
3
#
#

4
# Copyright (C) 2008, 2009, 2010, 2011, 2012 Google Inc.
Guido Trotter's avatar
Guido Trotter committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.


"""KVM hypervisor

"""

Balazs Lecz's avatar
Balazs Lecz committed
26
import errno
Guido Trotter's avatar
Guido Trotter committed
27
28
29
30
import os
import os.path
import re
import tempfile
31
import time
Guido Trotter's avatar
Guido Trotter committed
32
import logging
33
import pwd
34
35
import struct
import fcntl
36
import shutil
37
import socket
38
import stat
39
import StringIO
40
try:
Andrea Spadaccini's avatar
Andrea Spadaccini committed
41
  import affinity   # pylint: disable=F0401
42
43
except ImportError:
  affinity = None
Guido Trotter's avatar
Guido Trotter committed
44
45
46
47

from ganeti import utils
from ganeti import constants
from ganeti import errors
48
49
from ganeti import serializer
from ganeti import objects
50
51
from ganeti import uidpool
from ganeti import ssconf
52
from ganeti import netutils
53
54
from ganeti import pathutils
from ganeti.hypervisor import hv_base
55
from ganeti.utils import wrapper as utils_wrapper
Guido Trotter's avatar
Guido Trotter committed
56
57


58
_KVM_NETWORK_SCRIPT = pathutils.CONF_DIR + "/kvm-vif-bridge"
59
_KVM_START_PAUSED_FLAG = "-S"
60

61
62
63
64
65
66
67
68
69
70
# TUN/TAP driver constants, taken from <linux/if_tun.h>
# They are architecture-independent and already hardcoded in qemu-kvm source,
# so we can safely include them here.
TUNSETIFF = 0x400454ca
TUNGETIFF = 0x800454d2
TUNGETFEATURES = 0x800454cf
IFF_TAP = 0x0002
IFF_NO_PI = 0x1000
IFF_VNET_HDR = 0x4000

71
72
73
74
75
76
77
78
79
80
81
#: SPICE parameters which depend on L{constants.HV_KVM_SPICE_BIND}
_SPICE_ADDITIONAL_PARAMS = frozenset([
  constants.HV_KVM_SPICE_IP_VERSION,
  constants.HV_KVM_SPICE_PASSWORD_FILE,
  constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR,
  constants.HV_KVM_SPICE_JPEG_IMG_COMPR,
  constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR,
  constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION,
  constants.HV_KVM_SPICE_USE_TLS,
  ])

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

def _ProbeTapVnetHdr(fd):
  """Check whether to enable the IFF_VNET_HDR flag.

  To do this, _all_ of the following conditions must be met:
   1. TUNGETFEATURES ioctl() *must* be implemented
   2. TUNGETFEATURES ioctl() result *must* contain the IFF_VNET_HDR flag
   3. TUNGETIFF ioctl() *must* be implemented; reading the kernel code in
      drivers/net/tun.c there is no way to test this until after the tap device
      has been created using TUNSETIFF, and there is no way to change the
      IFF_VNET_HDR flag after creating the interface, catch-22! However both
      TUNGETIFF and TUNGETFEATURES were introduced in kernel version 2.6.27,
      thus we can expect TUNGETIFF to be present if TUNGETFEATURES is.

   @type fd: int
   @param fd: the file descriptor of /dev/net/tun

  """
  req = struct.pack("I", 0)
  try:
    res = fcntl.ioctl(fd, TUNGETFEATURES, req)
  except EnvironmentError:
    logging.warning("TUNGETFEATURES ioctl() not implemented")
    return False

  tunflags = struct.unpack("I", res)[0]
  if tunflags & IFF_VNET_HDR:
    return True
  else:
    logging.warning("Host does not support IFF_VNET_HDR, not enabling")
    return False


def _OpenTap(vnet_hdr=True):
  """Open a new tap device and return its file descriptor.

  This is intended to be used by a qemu-type hypervisor together with the -net
  tap,fd=<fd> command line parameter.

  @type vnet_hdr: boolean
  @param vnet_hdr: Enable the VNET Header
  @return: (ifname, tapfd)
  @rtype: tuple

  """
  try:
    tapfd = os.open("/dev/net/tun", os.O_RDWR)
  except EnvironmentError:
    raise errors.HypervisorError("Failed to open /dev/net/tun")

  flags = IFF_TAP | IFF_NO_PI

  if vnet_hdr and _ProbeTapVnetHdr(tapfd):
    flags |= IFF_VNET_HDR

  # The struct ifreq ioctl request (see netdevice(7))
  ifr = struct.pack("16sh", "", flags)

  try:
    res = fcntl.ioctl(tapfd, TUNSETIFF, ifr)
  except EnvironmentError:
    raise errors.HypervisorError("Failed to allocate a new TAP device")

  # Get the interface name from the ioctl
  ifname = struct.unpack("16sh", res)[0].strip("\x00")
  return (ifname, tapfd)

149

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
def _BuildNetworkEnv(name, network, gateway, network6, gateway6,
                     network_type, mac_prefix, tags, env):
  """Build environment variables concerning a Network.

  """
  if name:
    env["NETWORK_NAME"] = name
  if network:
    env["NETWORK_SUBNET"] = network
  if gateway:
    env["NETWORK_GATEWAY"] = gateway
  if network6:
    env["NETWORK_SUBNET6"] = network6
  if gateway6:
    env["NETWORK_GATEWAY6"] = gateway6
  if mac_prefix:
    env["NETWORK_MAC_PREFIX"] = mac_prefix
  if network_type:
    env["NETWORK_TYPE"] = network_type
  if tags:
    env["NETWORK_TAGS"] = " ".join(tags)

  return env


175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
class QmpMessage:
  """QEMU Messaging Protocol (QMP) message.

  """
  def __init__(self, data):
    """Creates a new QMP message based on the passed data.

    """
    if not isinstance(data, dict):
      raise TypeError("QmpMessage must be initialized with a dict")

    self.data = data

  def __getitem__(self, field_name):
    """Get the value of the required field if present, or None.

    Overrides the [] operator to provide access to the message data,
    returning None if the required item is not in the message
    @return: the value of the field_name field, or None if field_name
             is not contained in the message

    """
197
    return self.data.get(field_name, None)
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

  def __setitem__(self, field_name, field_value):
    """Set the value of the required field_name to field_value.

    """
    self.data[field_name] = field_value

  @staticmethod
  def BuildFromJsonString(json_string):
    """Build a QmpMessage from a JSON encoded string.

    @type json_string: str
    @param json_string: JSON string representing the message
    @rtype: L{QmpMessage}
    @return: a L{QmpMessage} built from json_string

    """
    # Parse the string
    data = serializer.LoadJson(json_string)
    return QmpMessage(data)

  def __str__(self):
220
221
    # The protocol expects the JSON object to be sent as a single line.
    return serializer.DumpJson(self.data)
222
223
224
225
226
227
228
229
230
231
232
233
234
235

  def __eq__(self, other):
    # When comparing two QmpMessages, we are interested in comparing
    # their internal representation of the message data
    return self.data == other.data


class QmpConnection:
  """Connection to the QEMU Monitor using the QEMU Monitor Protocol (QMP).

  """
  _FIRST_MESSAGE_KEY = "QMP"
  _EVENT_KEY = "event"
  _ERROR_KEY = "error"
236
237
  _RETURN_KEY = RETURN_KEY = "return"
  _ACTUAL_KEY = ACTUAL_KEY = "actual"
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
  _ERROR_CLASS_KEY = "class"
  _ERROR_DATA_KEY = "data"
  _ERROR_DESC_KEY = "desc"
  _EXECUTE_KEY = "execute"
  _ARGUMENTS_KEY = "arguments"
  _CAPABILITIES_COMMAND = "qmp_capabilities"
  _MESSAGE_END_TOKEN = "\r\n"
  _SOCKET_TIMEOUT = 5

  def __init__(self, monitor_filename):
    """Instantiates the QmpConnection object.

    @type monitor_filename: string
    @param monitor_filename: the filename of the UNIX raw socket on which the
                             QMP monitor is listening

    """
    self.monitor_filename = monitor_filename
    self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    # We want to fail if the server doesn't send a complete message
    # in a reasonable amount of time
    self.sock.settimeout(self._SOCKET_TIMEOUT)
    self._connected = False
    self._buf = ""

263
264
265
266
267
268
269
270
271
272
273
274
275
  def _check_socket(self):
    sock_stat = None
    try:
      sock_stat = os.stat(self.monitor_filename)
    except EnvironmentError, err:
      if err.errno == errno.ENOENT:
        raise errors.HypervisorError("No qmp socket found")
      else:
        raise errors.HypervisorError("Error checking qmp socket: %s",
                                     utils.ErrnoOrStr(err))
    if not stat.S_ISSOCK(sock_stat.st_mode):
      raise errors.HypervisorError("Qmp socket is not a socket")

276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
  def _check_connection(self):
    """Make sure that the connection is established.

    """
    if not self._connected:
      raise errors.ProgrammerError("To use a QmpConnection you need to first"
                                   " invoke connect() on it")

  def connect(self):
    """Connects to the QMP monitor.

    Connects to the UNIX socket and makes sure that we can actually send and
    receive data to the kvm instance via QMP.

    @raise errors.HypervisorError: when there are communication errors
    @raise errors.ProgrammerError: when there are data serialization errors

    """
294
295
296
297
298
299
300
301
302
303
    if self._connected:
      raise errors.ProgrammerError("Cannot connect twice")

    self._check_socket()

    # Check file existance/stuff
    try:
      self.sock.connect(self.monitor_filename)
    except EnvironmentError:
      raise errors.HypervisorError("Can't connect to qmp socket")
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
    self._connected = True

    # Check if we receive a correct greeting message from the server
    # (As per the QEMU Protocol Specification 0.1 - section 2.2)
    greeting = self._Recv()
    if not greeting[self._FIRST_MESSAGE_KEY]:
      self._connected = False
      raise errors.HypervisorError("kvm: qmp communication error (wrong"
                                   " server greeting")

    # Let's put the monitor in command mode using the qmp_capabilities
    # command, or else no command will be executable.
    # (As per the QEMU Protocol Specification 0.1 - section 4)
    self.Execute(self._CAPABILITIES_COMMAND)

  def _ParseMessage(self, buf):
    """Extract and parse a QMP message from the given buffer.

    Seeks for a QMP message in the given buf. If found, it parses it and
    returns it together with the rest of the characters in the buf.
    If no message is found, returns None and the whole buffer.

    @raise errors.ProgrammerError: when there are data serialization errors

    """
    message = None
    # Check if we got the message end token (CRLF, as per the QEMU Protocol
    # Specification 0.1 - Section 2.1.1)
    pos = buf.find(self._MESSAGE_END_TOKEN)
    if pos >= 0:
      try:
        message = QmpMessage.BuildFromJsonString(buf[:pos + 1])
      except Exception, err:
        raise errors.ProgrammerError("QMP data serialization error: %s" % err)
      buf = buf[pos + 1:]

    return (message, buf)

  def _Recv(self):
    """Receives a message from QMP and decodes the received JSON object.

    @rtype: QmpMessage
    @return: the received message
    @raise errors.HypervisorError: when there are communication errors
    @raise errors.ProgrammerError: when there are data serialization errors

    """
    self._check_connection()

    # Check if there is already a message in the buffer
    (message, self._buf) = self._ParseMessage(self._buf)
    if message:
      return message

    recv_buffer = StringIO.StringIO(self._buf)
    recv_buffer.seek(len(self._buf))
    try:
      while True:
        data = self.sock.recv(4096)
        if not data:
          break
        recv_buffer.write(data)

        (message, self._buf) = self._ParseMessage(recv_buffer.getvalue())
        if message:
          return message

    except socket.timeout, err:
      raise errors.HypervisorError("Timeout while receiving a QMP message: "
                                   "%s" % (err))
    except socket.error, err:
      raise errors.HypervisorError("Unable to receive data from KVM using the"
                                   " QMP protocol: %s" % err)

  def _Send(self, message):
    """Encodes and sends a message to KVM using QMP.

    @type message: QmpMessage
    @param message: message to send to KVM
    @raise errors.HypervisorError: when there are communication errors
    @raise errors.ProgrammerError: when there are data serialization errors

    """
    self._check_connection()
    try:
      message_str = str(message)
    except Exception, err:
      raise errors.ProgrammerError("QMP data deserialization error: %s" % err)

    try:
      self.sock.sendall(message_str)
    except socket.timeout, err:
      raise errors.HypervisorError("Timeout while sending a QMP message: "
                                   "%s (%s)" % (err.string, err.errno))
    except socket.error, err:
      raise errors.HypervisorError("Unable to send data from KVM using the"
                                   " QMP protocol: %s" % err)

  def Execute(self, command, arguments=None):
    """Executes a QMP command and returns the response of the server.

    @type command: str
    @param command: the command to execute
    @type arguments: dict
    @param arguments: dictionary of arguments to be passed to the command
    @rtype: dict
    @return: dictionary representing the received JSON object
    @raise errors.HypervisorError: when there are communication errors
    @raise errors.ProgrammerError: when there are data serialization errors

    """
    self._check_connection()
    message = QmpMessage({self._EXECUTE_KEY: command})
    if arguments:
      message[self._ARGUMENTS_KEY] = arguments
    self._Send(message)

    # Events can occur between the sending of the command and the reception
    # of the response, so we need to filter out messages with the event key.
    while True:
      response = self._Recv()
      err = response[self._ERROR_KEY]
      if err:
        raise errors.HypervisorError("kvm: error executing the %s"
                                     " command: %s (%s, %s):" %
                                     (command,
                                      err[self._ERROR_DESC_KEY],
                                      err[self._ERROR_CLASS_KEY],
                                      err[self._ERROR_DATA_KEY]))

      elif not response[self._EVENT_KEY]:
        return response


Guido Trotter's avatar
Guido Trotter committed
438
class KVMHypervisor(hv_base.BaseHypervisor):
Michael Hanselmann's avatar
Michael Hanselmann committed
439
440
441
  """KVM hypervisor interface

  """
442
  CAN_MIGRATE = True
Guido Trotter's avatar
Guido Trotter committed
443

444
  _ROOT_DIR = pathutils.RUN_DIR + "/kvm-hypervisor"
Guido Trotter's avatar
Guido Trotter committed
445
  _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids
446
  _UIDS_DIR = _ROOT_DIR + "/uid" # contains instances reserved uids
Guido Trotter's avatar
Guido Trotter committed
447
448
  _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets
  _CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data
449
  _NICS_DIR = _ROOT_DIR + "/nic" # contains instances nic <-> tap associations
450
  _KEYMAP_DIR = _ROOT_DIR + "/keymap" # contains instances keymaps
Balazs Lecz's avatar
Balazs Lecz committed
451
452
453
454
455
456
457
458
  # KVM instances with chroot enabled are started in empty chroot directories.
  _CHROOT_DIR = _ROOT_DIR + "/chroot" # for empty chroot directories
  # After an instance is stopped, its chroot directory is removed.
  # If the chroot directory is not empty, it can't be removed.
  # A non-empty chroot directory indicates a possible security incident.
  # To support forensics, the non-empty chroot directory is quarantined in
  # a separate directory, called 'chroot-quarantine'.
  _CHROOT_QUARANTINE_DIR = _ROOT_DIR + "/chroot-quarantine"
459
  _DIRS = [_ROOT_DIR, _PIDS_DIR, _UIDS_DIR, _CTRL_DIR, _CONF_DIR, _NICS_DIR,
460
           _CHROOT_DIR, _CHROOT_QUARANTINE_DIR, _KEYMAP_DIR]
Guido Trotter's avatar
Guido Trotter committed
461

462
463
464
465
466
467
468
  PARAMETERS = {
    constants.HV_KERNEL_PATH: hv_base.OPT_FILE_CHECK,
    constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
    constants.HV_ROOT_PATH: hv_base.NO_CHECK,
    constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
    constants.HV_ACPI: hv_base.NO_CHECK,
    constants.HV_SERIAL_CONSOLE: hv_base.NO_CHECK,
Guido Trotter's avatar
Guido Trotter committed
469
    constants.HV_SERIAL_SPEED: hv_base.NO_CHECK,
Michael Hanselmann's avatar
Michael Hanselmann committed
470
    constants.HV_VNC_BIND_ADDRESS:
471
472
      (False, lambda x: (netutils.IP4Address.IsValid(x) or
                         utils.IsNormAbsPath(x)),
Michael Hanselmann's avatar
Michael Hanselmann committed
473
474
       "the VNC bind address must be either a valid IP address or an absolute"
       " pathname", None, None),
475
476
477
    constants.HV_VNC_TLS: hv_base.NO_CHECK,
    constants.HV_VNC_X509: hv_base.OPT_DIR_CHECK,
    constants.HV_VNC_X509_VERIFY: hv_base.NO_CHECK,
478
    constants.HV_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
479
480
481
482
483
484
    constants.HV_KVM_SPICE_BIND: hv_base.NO_CHECK, # will be checked later
    constants.HV_KVM_SPICE_IP_VERSION:
      (False, lambda x: (x == constants.IFACE_NO_IP_VERSION_SPECIFIED or
                         x in constants.VALID_IP_VERSIONS),
       "the SPICE IP version should be 4 or 6",
       None, None),
485
    constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
486
    constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:
Iustin Pop's avatar
Iustin Pop committed
487
488
      hv_base.ParamInSet(
        False, constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),
489
    constants.HV_KVM_SPICE_JPEG_IMG_COMPR:
Iustin Pop's avatar
Iustin Pop committed
490
491
      hv_base.ParamInSet(
        False, constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
492
    constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:
Iustin Pop's avatar
Iustin Pop committed
493
494
      hv_base.ParamInSet(
        False, constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
495
    constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:
Iustin Pop's avatar
Iustin Pop committed
496
497
      hv_base.ParamInSet(
        False, constants.HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS),
498
    constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,
499
    constants.HV_KVM_SPICE_USE_TLS: hv_base.NO_CHECK,
500
501
    constants.HV_KVM_SPICE_TLS_CIPHERS: hv_base.NO_CHECK,
    constants.HV_KVM_SPICE_USE_VDAGENT: hv_base.NO_CHECK,
502
    constants.HV_KVM_FLOPPY_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
503
    constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
504
    constants.HV_KVM_CDROM2_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
Michael Hanselmann's avatar
Michael Hanselmann committed
505
506
507
508
509
510
    constants.HV_BOOT_ORDER:
      hv_base.ParamInSet(True, constants.HT_KVM_VALID_BO_TYPES),
    constants.HV_NIC_TYPE:
      hv_base.ParamInSet(True, constants.HT_KVM_VALID_NIC_TYPES),
    constants.HV_DISK_TYPE:
      hv_base.ParamInSet(True, constants.HT_KVM_VALID_DISK_TYPES),
511
512
    constants.HV_KVM_CDROM_DISK_TYPE:
      hv_base.ParamInSet(False, constants.HT_KVM_VALID_DISK_TYPES),
Michael Hanselmann's avatar
Michael Hanselmann committed
513
514
    constants.HV_USB_MOUSE:
      hv_base.ParamInSet(False, constants.HT_KVM_VALID_MOUSE_TYPES),
515
    constants.HV_KEYMAP: hv_base.NO_CHECK,
516
    constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
517
518
    constants.HV_MIGRATION_BANDWIDTH: hv_base.REQ_NONNEGATIVE_INT_CHECK,
    constants.HV_MIGRATION_DOWNTIME: hv_base.REQ_NONNEGATIVE_INT_CHECK,
519
    constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
520
    constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
521
522
    constants.HV_DISK_CACHE:
      hv_base.ParamInSet(True, constants.HT_VALID_CACHE_TYPES),
523
524
525
    constants.HV_SECURITY_MODEL:
      hv_base.ParamInSet(True, constants.HT_KVM_VALID_SM_TYPES),
    constants.HV_SECURITY_DOMAIN: hv_base.NO_CHECK,
Guido Trotter's avatar
Guido Trotter committed
526
527
    constants.HV_KVM_FLAG:
      hv_base.ParamInSet(False, constants.HT_KVM_FLAG_VALUES),
528
    constants.HV_VHOST_NET: hv_base.NO_CHECK,
Balazs Lecz's avatar
Balazs Lecz committed
529
    constants.HV_KVM_USE_CHROOT: hv_base.NO_CHECK,
530
    constants.HV_MEM_PATH: hv_base.OPT_DIR_CHECK,
531
    constants.HV_REBOOT_BEHAVIOR:
532
533
      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
    constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,
534
    constants.HV_CPU_TYPE: hv_base.NO_CHECK,
535
536
537
    constants.HV_CPU_CORES: hv_base.OPT_NONNEGATIVE_INT_CHECK,
    constants.HV_CPU_THREADS: hv_base.OPT_NONNEGATIVE_INT_CHECK,
    constants.HV_CPU_SOCKETS: hv_base.OPT_NONNEGATIVE_INT_CHECK,
Guido Trotter's avatar
Guido Trotter committed
538
    constants.HV_SOUNDHW: hv_base.NO_CHECK,
Guido Trotter's avatar
Guido Trotter committed
539
    constants.HV_USB_DEVICES: hv_base.NO_CHECK,
Guido Trotter's avatar
Guido Trotter committed
540
    constants.HV_VGA: hv_base.NO_CHECK,
Guido Trotter's avatar
Guido Trotter committed
541
    constants.HV_KVM_EXTRA: hv_base.NO_CHECK,
542
    constants.HV_KVM_MACHINE_VERSION: hv_base.NO_CHECK,
543
    }
544

Iustin Pop's avatar
Iustin Pop committed
545
  _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",
Guido Trotter's avatar
Guido Trotter committed
546
                                    re.M | re.I)
Michael Hanselmann's avatar
Michael Hanselmann committed
547
  _MIGRATION_PROGRESS_RE = \
548
549
550
    re.compile(r"\s*transferred\s+ram:\s+(?P<transferred>\d+)\s+kbytes\s*\n"
               r"\s*remaining\s+ram:\s+(?P<remaining>\d+)\s+kbytes\s*\n"
               r"\s*total\s+ram:\s+(?P<total>\d+)\s+kbytes\s*\n", re.I)
551

552
553
  _MIGRATION_INFO_MAX_BAD_ANSWERS = 5
  _MIGRATION_INFO_RETRY_DELAY = 2
Guido Trotter's avatar
Guido Trotter committed
554

555
  _VERSION_RE = re.compile(r"\b(\d+)\.(\d+)(\.(\d+))?\b")
556

557
558
559
560
  _CPU_INFO_RE = re.compile(r"cpu\s+\#(\d+).*thread_id\s*=\s*(\d+)", re.I)
  _CPU_INFO_CMD = "info cpus"
  _CONT_CMD = "cont"

561
  _DEFAULT_MACHINE_VERSION_RE = re.compile(r"^(\S+).*\(default\)", re.M)
562

563
564
565
566
567
568
569
570
571
572
573
  _QMP_RE = re.compile(r"^-qmp\s", re.M)
  _SPICE_RE = re.compile(r"^-spice\s", re.M)
  _VHOST_RE = re.compile(r"^-net\s.*,vhost=on|off", re.M)
  _ENABLE_KVM_RE = re.compile(r"^-enable-kvm\s", re.M)
  _DISABLE_KVM_RE = re.compile(r"^-disable-kvm\s", re.M)
  _NETDEV_RE = re.compile(r"^-netdev\s", re.M)
  # match  -drive.*boot=on|off on different lines, but in between accept only
  # dashes not preceeded by a new line (which would mean another option
  # different than -drive is starting)
  _BOOT_RE = re.compile(r"^-drive\s([^-]|(?<!^)-)*,boot=on\|off", re.M | re.S)

574
575
576
  ANCILLARY_FILES = [
    _KVM_NETWORK_SCRIPT,
    ]
577
578
579
  ANCILLARY_FILES_OPT = [
    _KVM_NETWORK_SCRIPT,
    ]
580

Guido Trotter's avatar
Guido Trotter committed
581
582
583
584
  def __init__(self):
    hv_base.BaseHypervisor.__init__(self)
    # Let's make sure the directories we need exist, even if the RUN_DIR lives
    # in a tmpfs filesystem or has been otherwise wiped out.
Iustin Pop's avatar
Iustin Pop committed
585
    dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]
Guido Trotter's avatar
Guido Trotter committed
586
    utils.EnsureDirs(dirs)
Guido Trotter's avatar
Guido Trotter committed
587

588
589
  @classmethod
  def _InstancePidFile(cls, instance_name):
590
591
592
    """Returns the instance pidfile.

    """
593
    return utils.PathJoin(cls._PIDS_DIR, instance_name)
594

595
596
597
598
599
600
601
  @classmethod
  def _InstanceUidFile(cls, instance_name):
    """Returns the instance uidfile.

    """
    return utils.PathJoin(cls._UIDS_DIR, instance_name)

602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
  @classmethod
  def _InstancePidInfo(cls, pid):
    """Check pid file for instance information.

    Check that a pid file is associated with an instance, and retrieve
    information from its command line.

    @type pid: string or int
    @param pid: process id of the instance to check
    @rtype: tuple
    @return: (instance_name, memory, vcpus)
    @raise errors.HypervisorError: when an instance cannot be found

    """
    alive = utils.IsProcessAlive(pid)
    if not alive:
      raise errors.HypervisorError("Cannot get info for pid %s" % pid)

    cmdline_file = utils.PathJoin("/proc", str(pid), "cmdline")
    try:
      cmdline = utils.ReadFile(cmdline_file)
    except EnvironmentError, err:
      raise errors.HypervisorError("Can't open cmdline file for pid %s: %s" %
                                   (pid, err))

    instance = None
    memory = 0
    vcpus = 0

Iustin Pop's avatar
Iustin Pop committed
631
    arg_list = cmdline.split("\x00")
632
    while arg_list:
Michael Hanselmann's avatar
Michael Hanselmann committed
633
      arg = arg_list.pop(0)
634
635
636
637
638
      if arg == "-name":
        instance = arg_list.pop(0)
      elif arg == "-m":
        memory = int(arg_list.pop(0))
      elif arg == "-smp":
639
        vcpus = int(arg_list.pop(0).split(",")[0])
640
641
642
643
644
645
646

    if instance is None:
      raise errors.HypervisorError("Pid %s doesn't contain a ganeti kvm"
                                   " instance" % pid)

    return (instance, memory, vcpus)

647
  def _InstancePidAlive(self, instance_name):
648
649
650
651
652
653
    """Returns the instance pidfile, pid, and liveness.

    @type instance_name: string
    @param instance_name: instance name
    @rtype: tuple
    @return: (pid file name, pid, liveness)
654
655

    """
656
    pidfile = self._InstancePidFile(instance_name)
657
    pid = utils.ReadPidFile(pidfile)
658
659
660
661
662
663
664

    alive = False
    try:
      cmd_instance = self._InstancePidInfo(pid)[0]
      alive = (cmd_instance == instance_name)
    except errors.HypervisorError:
      pass
665
666
667

    return (pidfile, pid, alive)

668
669
670
671
672
673
674
675
676
  def _CheckDown(self, instance_name):
    """Raises an error unless the given instance is down.

    """
    alive = self._InstancePidAlive(instance_name)[2]
    if alive:
      raise errors.HypervisorError("Failed to start instance %s: %s" %
                                   (instance_name, "already running"))

677
678
  @classmethod
  def _InstanceMonitor(cls, instance_name):
679
680
681
    """Returns the instance monitor socket name

    """
682
    return utils.PathJoin(cls._CTRL_DIR, "%s.monitor" % instance_name)
683

684
685
  @classmethod
  def _InstanceSerial(cls, instance_name):
686
687
688
    """Returns the instance serial socket name

    """
689
    return utils.PathJoin(cls._CTRL_DIR, "%s.serial" % instance_name)
690

691
692
693
694
695
696
697
  @classmethod
  def _InstanceQmpMonitor(cls, instance_name):
    """Returns the instance serial QMP socket name

    """
    return utils.PathJoin(cls._CTRL_DIR, "%s.qmp" % instance_name)

698
699
700
701
702
703
704
  @staticmethod
  def _SocatUnixConsoleParams():
    """Returns the correct parameters for socat

    If we have a new-enough socat we can use raw mode with an escape character.

    """
705
    if constants.SOCAT_USE_ESCAPE:
706
707
708
709
      return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE
    else:
      return "echo=0,icanon=0"

710
711
  @classmethod
  def _InstanceKVMRuntime(cls, instance_name):
712
713
714
    """Returns the instance KVM runtime filename

    """
715
    return utils.PathJoin(cls._CONF_DIR, "%s.runtime" % instance_name)
716

Balazs Lecz's avatar
Balazs Lecz committed
717
718
719
720
721
722
723
  @classmethod
  def _InstanceChrootDir(cls, instance_name):
    """Returns the name of the KVM chroot dir of the instance

    """
    return utils.PathJoin(cls._CHROOT_DIR, instance_name)

724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
  @classmethod
  def _InstanceNICDir(cls, instance_name):
    """Returns the name of the directory holding the tap device files for a
    given instance.

    """
    return utils.PathJoin(cls._NICS_DIR, instance_name)

  @classmethod
  def _InstanceNICFile(cls, instance_name, seq):
    """Returns the name of the file containing the tap device for a given NIC

    """
    return utils.PathJoin(cls._InstanceNICDir(instance_name), str(seq))

739
740
741
742
743
744
745
  @classmethod
  def _InstanceKeymapFile(cls, instance_name):
    """Returns the name of the file containing the keymap for a given instance

    """
    return utils.PathJoin(cls._KEYMAP_DIR, instance_name)

746
747
748
749
750
751
752
  @classmethod
  def _TryReadUidFile(cls, uid_file):
    """Try to read a uid file

    """
    if os.path.exists(uid_file):
      try:
753
        uid = int(utils.ReadOneLineFile(uid_file))
754
        return uid
755
756
757
758
      except EnvironmentError:
        logging.warning("Can't read uid file", exc_info=True)
      except (TypeError, ValueError):
        logging.warning("Can't parse uid file contents", exc_info=True)
759
    return None
760

761
762
  @classmethod
  def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):
Balazs Lecz's avatar
Balazs Lecz committed
763
    """Removes an instance's rutime sockets/files/dirs.
764
765
766
767
768

    """
    utils.RemoveFile(pidfile)
    utils.RemoveFile(cls._InstanceMonitor(instance_name))
    utils.RemoveFile(cls._InstanceSerial(instance_name))
769
    utils.RemoveFile(cls._InstanceQmpMonitor(instance_name))
770
    utils.RemoveFile(cls._InstanceKVMRuntime(instance_name))
771
    utils.RemoveFile(cls._InstanceKeymapFile(instance_name))
772
773
774
775
776
    uid_file = cls._InstanceUidFile(instance_name)
    uid = cls._TryReadUidFile(uid_file)
    utils.RemoveFile(uid_file)
    if uid is not None:
      uidpool.ReleaseUid(uid)
777
778
779
780
781
    try:
      shutil.rmtree(cls._InstanceNICDir(instance_name))
    except OSError, err:
      if err.errno != errno.ENOENT:
        raise
Balazs Lecz's avatar
Balazs Lecz committed
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
    try:
      chroot_dir = cls._InstanceChrootDir(instance_name)
      utils.RemoveDir(chroot_dir)
    except OSError, err:
      if err.errno == errno.ENOTEMPTY:
        # The chroot directory is expected to be empty, but it isn't.
        new_chroot_dir = tempfile.mkdtemp(dir=cls._CHROOT_QUARANTINE_DIR,
                                          prefix="%s-%s-" %
                                          (instance_name,
                                           utils.TimestampForFilename()))
        logging.warning("The chroot directory of instance %s can not be"
                        " removed as it is not empty. Moving it to the"
                        " quarantine instead. Please investigate the"
                        " contents (%s) and clean up manually",
                        instance_name, new_chroot_dir)
        utils.RenameFile(chroot_dir, new_chroot_dir)
      else:
        raise
800

801
  @staticmethod
802
803
  def _ConfigureNIC(instance, seq, nic, tap):
    """Run the network configuration script for a specified NIC
Guido Trotter's avatar
Guido Trotter committed
804
805
806
807
808
809
810

    @param instance: instance we're acting on
    @type instance: instance object
    @param seq: nic sequence number
    @type seq: int
    @param nic: nic we're acting on
    @type nic: nic object
811
812
    @param tap: the host's tap interface this NIC corresponds to
    @type tap: str
Guido Trotter's avatar
Guido Trotter committed
813
814

    """
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
    if instance.tags:
      tags = " ".join(instance.tags)
    else:
      tags = ""

    env = {
      "PATH": "%s:/sbin:/usr/sbin" % os.environ["PATH"],
      "INSTANCE": instance.name,
      "MAC": nic.mac,
      "MODE": nic.nicparams[constants.NIC_MODE],
      "INTERFACE": tap,
      "INTERFACE_INDEX": str(seq),
      "TAGS": tags,
    }

    if nic.ip:
      env["IP"] = nic.ip

    if nic.nicparams[constants.NIC_LINK]:
      env["LINK"] = nic.nicparams[constants.NIC_LINK]

836
    if nic.network:
Dimitris Aragiorgis's avatar
Dimitris Aragiorgis committed
837
838
839
840
      n = objects.Network.FromDict(nic.netinfo)
      _BuildNetworkEnv(nic.network, n.network, n.gateway,
                       n.network6, n.gateway6, n.network_type,
                       n.mac_prefix, n.tags, env)
841

842
843
844
    if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
      env["BRIDGE"] = nic.nicparams[constants.NIC_LINK]

845
    result = utils.RunCmd([pathutils.KVM_IFUP, tap], env=env)
846
847
848
849
    if result.failed:
      raise errors.HypervisorError("Failed to configure interface %s: %s."
                                   " Network configuration script output: %s" %
                                   (tap, result.fail_reason, result.output))
Guido Trotter's avatar
Guido Trotter committed
850

851
852
853
854
  @staticmethod
  def _VerifyAffinityPackage():
    if affinity is None:
      raise errors.HypervisorError("affinity Python package not"
Iustin Pop's avatar
Iustin Pop committed
855
                                   " found; cannot use CPU pinning under KVM")
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900

  @staticmethod
  def _BuildAffinityCpuMask(cpu_list):
    """Create a CPU mask suitable for sched_setaffinity from a list of
    CPUs.

    See man taskset for more info on sched_setaffinity masks.
    For example: [ 0, 2, 5, 6 ] will return 101 (0x65, 0..01100101).

    @type cpu_list: list of int
    @param cpu_list: list of physical CPU numbers to map to vCPUs in order
    @rtype: int
    @return: a bit mask of CPU affinities

    """
    if cpu_list == constants.CPU_PINNING_OFF:
      return constants.CPU_PINNING_ALL_KVM
    else:
      return sum(2 ** cpu for cpu in cpu_list)

  @classmethod
  def _AssignCpuAffinity(cls, cpu_mask, process_id, thread_dict):
    """Change CPU affinity for running VM according to given CPU mask.

    @param cpu_mask: CPU mask as given by the user. e.g. "0-2,4:all:1,3"
    @type cpu_mask: string
    @param process_id: process ID of KVM process. Used to pin entire VM
                       to physical CPUs.
    @type process_id: int
    @param thread_dict: map of virtual CPUs to KVM thread IDs
    @type thread_dict: dict int:int

    """
    # Convert the string CPU mask to a list of list of int's
    cpu_list = utils.ParseMultiCpuMask(cpu_mask)

    if len(cpu_list) == 1:
      all_cpu_mapping = cpu_list[0]
      if all_cpu_mapping == constants.CPU_PINNING_OFF:
        # If CPU pinning has 1 entry that's "all", then do nothing
        pass
      else:
        # If CPU pinning has one non-all entry, map the entire VM to
        # one set of physical CPUs
        cls._VerifyAffinityPackage()
Iustin Pop's avatar
Iustin Pop committed
901
902
        affinity.set_process_affinity_mask(
          process_id, cls._BuildAffinityCpuMask(all_cpu_mapping))
903
904
905
906
907
908
909
910
911
912
    else:
      # The number of vCPUs mapped should match the number of vCPUs
      # reported by KVM. This was already verified earlier, so
      # here only as a sanity check.
      assert len(thread_dict) == len(cpu_list)
      cls._VerifyAffinityPackage()

      # For each vCPU, map it to the proper list of physical CPUs
      for vcpu, i in zip(cpu_list, range(len(cpu_list))):
        affinity.set_process_affinity_mask(thread_dict[i],
Iustin Pop's avatar
Iustin Pop committed
913
                                           cls._BuildAffinityCpuMask(vcpu))
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934

  def _GetVcpuThreadIds(self, instance_name):
    """Get a mapping of vCPU no. to thread IDs for the instance

    @type instance_name: string
    @param instance_name: instance in question
    @rtype: dictionary of int:int
    @return: a dictionary mapping vCPU numbers to thread IDs

    """
    result = {}
    output = self._CallMonitorCommand(instance_name, self._CPU_INFO_CMD)
    for line in output.stdout.splitlines():
      match = self._CPU_INFO_RE.search(line)
      if not match:
        continue
      grp = map(int, match.groups())
      result[grp[0]] = grp[1]

    return result

935
936
  def _ExecuteCpuAffinity(self, instance_name, cpu_mask):
    """Complete CPU pinning.
937
938
939
940
941
942
943

    @type instance_name: string
    @param instance_name: name of instance
    @type cpu_mask: string
    @param cpu_mask: CPU pinning mask as entered by user

    """
944
945
946
947
948
949
    # Get KVM process ID, to be used if need to pin entire VM
    _, pid, _ = self._InstancePidAlive(instance_name)
    # Get vCPU thread IDs, to be used if need to pin vCPUs separately
    thread_dict = self._GetVcpuThreadIds(instance_name)
    # Run CPU pinning, based on configured mask
    self._AssignCpuAffinity(cpu_mask, pid, thread_dict)
950

Guido Trotter's avatar
Guido Trotter committed
951
952
953
  def ListInstances(self):
    """Get the list of running instances.

Iustin Pop's avatar
Iustin Pop committed
954
955
    We can do this by listing our live instances directory and
    checking whether the associated kvm process is still alive.
Guido Trotter's avatar
Guido Trotter committed
956
957
958
959

    """
    result = []
    for name in os.listdir(self._PIDS_DIR):
960
      if self._InstancePidAlive(name)[2]:
Guido Trotter's avatar
Guido Trotter committed
961
962
963
964
965
966
        result.append(name)
    return result

  def GetInstanceInfo(self, instance_name):
    """Get instance properties.

967
    @type instance_name: string
Iustin Pop's avatar
Iustin Pop committed
968
    @param instance_name: the instance name
969
970
    @rtype: tuple of strings
    @return: (name, id, memory, vcpus, stat, times)
Guido Trotter's avatar
Guido Trotter committed
971
972

    """
973
    _, pid, alive = self._InstancePidAlive(instance_name)
974
    if not alive:
Guido Trotter's avatar
Guido Trotter committed
975
976
      return None

977
    _, memory, vcpus = self._InstancePidInfo(pid)
978
    istat = "---b-"
Guido Trotter's avatar
Guido Trotter committed
979
980
    times = "0"

981
982
983
984
985
986
987
988
989
990
991
    try:
      qmp = QmpConnection(self._InstanceQmpMonitor(instance_name))
      qmp.connect()
      vcpus = len(qmp.Execute("query-cpus")[qmp.RETURN_KEY])
      # Will fail if ballooning is not enabled, but we can then just resort to
      # the value above.
      mem_bytes = qmp.Execute("query-balloon")[qmp.RETURN_KEY][qmp.ACTUAL_KEY]
      memory = mem_bytes / 1048576
    except errors.HypervisorError:
      pass

992
    return (instance_name, pid, memory, vcpus, istat, times)
Guido Trotter's avatar
Guido Trotter committed
993
994
995
996

  def GetAllInstancesInfo(self):
    """Get properties of all instances.

Iustin Pop's avatar
Iustin Pop committed
997
998
    @return: list of tuples (name, id, memory, vcpus, stat, times)

Guido Trotter's avatar
Guido Trotter committed
999
1000
1001
    """
    data = []
    for name in os.listdir(self._PIDS_DIR):
1002
1003
1004
      try:
        info = self.GetInstanceInfo(name)
      except errors.HypervisorError:
1005
        # Ignore exceptions due to instances being shut down
1006
1007
1008
        continue
      if info:
        data.append(info)
Guido Trotter's avatar
Guido Trotter committed
1009
1010
    return data

1011
  def _GenerateKVMRuntime(self, instance, block_devices, startup_paused):
1012
    """Generate KVM information to start an instance.
Guido Trotter's avatar
Guido Trotter committed
1013

1014
1015
1016
1017
1018
1019
1020
    @attention: this function must not have any side-effects; for
        example, it must not write to the filesystem, or read values
        from the current system the are expected to differ between
        nodes, since it is only run once at instance startup;
        actions/kvm arguments that can vary between systems should be
        done in L{_ExecuteKVMRuntime}

Guido Trotter's avatar
Guido Trotter committed
1021
    """
1022
    # pylint: disable=R0912,R0914,R0915
1023
    kvmhelp = self._GetKVMHelpOutput()
1024
    hvp = instance.hvparams
1025

Michael Hanselmann's avatar
Michael Hanselmann committed
1026
    pidfile = self._InstancePidFile(instance.name)
Guido Trotter's avatar
Guido Trotter committed
1027
1028
    kvm = constants.KVM_PATH
    kvm_cmd = [kvm]
1029
    # used just by the vnc server, if enabled
Iustin Pop's avatar
Iustin Pop committed
1030
    kvm_cmd.extend(["-name", instance.name])
1031
    kvm_cmd.extend(["-m", instance.beparams[constants.BE_MAXMEM]])
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042

    smp_list = ["%s" % instance.beparams[constants.BE_VCPUS]]
    if hvp[constants.HV_CPU_CORES]:
      smp_list.append("cores=%s" % hvp[constants.HV_CPU_CORES])
    if hvp[constants.HV_CPU_THREADS]:
      smp_list.append("threads=%s" % hvp[constants.HV_CPU_THREADS])
    if hvp[constants.HV_CPU_SOCKETS]:
      smp_list.append("sockets=%s" % hvp[constants.HV_CPU_SOCKETS])

    kvm_cmd.extend(["-smp", ",".join(smp_list)])

Iustin Pop's avatar
Iustin Pop committed
1043
    kvm_cmd.extend(["-pidfile", pidfile])
1044
    kvm_cmd.extend(["-balloon", "virtio"])
Iustin Pop's avatar
Iustin Pop committed
1045
    kvm_cmd.extend(["-daemonize"])
1046
    if not instance.hvparams[constants.HV_ACPI]:
Iustin Pop's avatar
Iustin Pop committed
1047
      kvm_cmd.extend(["-no-acpi"])
1048
1049
1050
    if instance.hvparams[constants.HV_REBOOT_BEHAVIOR] == \
        constants.INSTANCE_REBOOT_EXIT:
      kvm_cmd.extend(["-no-reboot"])
Guido Trotter's avatar
Guido Trotter committed
1051

1052
1053
1054
1055
1056
    mversion = hvp[constants.HV_KVM_MACHINE_VERSION]
    if not mversion:
      mversion = self._GetDefaultMachineVersion()
    kvm_cmd.extend(["-M", mversion])

Iustin Pop's avatar
Iustin Pop committed
1057
1058
1059
1060
1061
1062
1063
1064
    kernel_path = hvp[constants.HV_KERNEL_PATH]
    if kernel_path:
      boot_disk = boot_cdrom = boot_floppy = boot_network = False
    else:
      boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
      boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM
      boot_floppy = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_FLOPPY
      boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
Guido Trotter's avatar
Guido Trotter committed
1065

1066
1067
    self.ValidateParameters(hvp)

1068
1069
1070
    if startup_paused:
      kvm_cmd.extend([_KVM_START_PAUSED_FLAG])

1071
1072
    if (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED and
        self._ENABLE_KVM_RE.search(kvmhelp)):
Guido Trotter's avatar
Guido Trotter committed
1073
      kvm_cmd.extend(["-enable-kvm"])
1074
1075
    elif (hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED and
          self._DISABLE_KVM_RE.search(kvmhelp)):
Guido Trotter's avatar
Guido Trotter committed
1076
1077
      kvm_cmd.extend(["-disable-kvm"])

Guido Trotter's avatar
Guido Trotter committed
1078
    if boot_network:
Iustin Pop's avatar
Iustin Pop committed
1079
      kvm_cmd.extend(["-boot", "n"])
1080

Iustin Pop's avatar
Iustin Pop committed
1081
1082
    # whether this is an older KVM version that uses the boot=on flag
    # on devices
1083
    needs_boot_flag = self._BOOT_RE.search(kvmhelp)
Iustin Pop's avatar
Iustin Pop committed
1084

1085
    disk_type = hvp[constants.HV_DISK_TYPE]
1086
    if disk_type == constants.HT_DISK_PARAVIRTUAL:
Iustin Pop's avatar
Iustin Pop committed
1087
      if_val = ",if=virtio"
1088
    else:
Iustin Pop's avatar
Iustin Pop committed
1089
      if_val = ",if=%s" % disk_type
1090
1091
    # Cache mode
    disk_cache = hvp[constants.HV_DISK_CACHE]
1092
1093
1094
1095
1096
1097
1098
1099
    if instance.disk_template in constants.DTS_EXT_MIRROR:
      if disk_cache != "none":
        # TODO: make this a hard error, instead of a silent overwrite
        logging.warning("KVM: overriding disk_cache setting '%s' with 'none'"
                        " to prevent shared storage corruption on migration",
                        disk_cache)
      cache_val = ",cache=none"
    elif disk_cache != constants.HT_CACHE_DEFAULT:
1100
1101
1102
      cache_val = ",cache=%s" % disk_cache
    else:
      cache_val = ""
1103
    for cfdev, dev_path in block_devices:
1104
1105
1106
      if cfdev.mode != constants.DISK_RDWR:
        raise errors.HypervisorError("Instance has read-only disks which"
                                     " are not supported by KVM")
Guido Trotter's avatar
Guido Trotter committed
1107
      # TODO: handle FD_LOOP and FD_BLKTAP (?)
1108
      boot_val = ""
1109
      if boot_disk:
Iustin Pop's avatar
Iustin Pop committed
1110
        kvm_cmd.extend(["-boot", "c"])
1111
        boot_disk = False
Iustin Pop's avatar
Iustin Pop committed
1112
        if needs_boot_flag and disk_type != constants.HT_DISK_IDE:
1113
          boot_val = ",boot=on"
Guido Trotter's avatar
Guido Trotter committed
1114

Iustin Pop's avatar
Iustin Pop committed
1115
      drive_val = "file=%s,format=raw%s%s%s" % (dev_path, if_val, boot_val,
1116
                                                cache_val)
Iustin Pop's avatar
Iustin Pop committed
1117
      kvm_cmd.extend(["-drive", drive_val])
Guido Trotter's avatar
Guido Trotter committed
1118

1119
1120
1121
1122
1123
    #Now we can specify a different device type for CDROM devices.
    cdrom_disk_type = hvp[constants.HV_KVM_CDROM_DISK_TYPE]
    if not cdrom_disk_type:
      cdrom_disk_type = disk_type

1124
    iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
1125
    if iso_image:
Iustin Pop's avatar
Iustin Pop committed
1126
      options = ",format=raw,media=cdrom"
Iustin Pop's avatar
Iustin Pop committed
1127
      # set cdrom 'if' type
1128
      if boot_cdrom:
Iustin Pop's avatar
Iustin Pop committed
1129
1130
1131
        actual_cdrom_type = constants.HT_DISK_IDE
      elif cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
        actual_cdrom_type = "virtio"
1132
      else:
Iustin Pop's avatar
Iustin Pop committed
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
        actual_cdrom_type = cdrom_disk_type
      if_val = ",if=%s" % actual_cdrom_type
      # set boot flag, if needed
      boot_val = ""
      if boot_cdrom:
        kvm_cmd.extend(["-boot", "d"])
        if needs_boot_flag:
          boot_val = ",boot=on"
      # and finally build the entire '-drive' value
      drive_val = "file=%s%s%s%s" % (iso_image, options, if_val, boot_val)
Iustin Pop's avatar
Iustin Pop committed
1143
      kvm_cmd.extend(["-drive", drive_val])
1144

1145
1146
    iso_image2 = hvp[constants.HV_KVM_CDROM2_IMAGE_PATH]
    if iso_image2:
Iustin Pop's avatar
Iustin Pop committed
1147
      options = ",format=raw,media=cdrom"
1148
      if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
Iustin Pop's avatar
Iustin Pop committed
1149
        if_val = ",if=virtio"
1150
      else:
Iustin Pop's avatar
Iustin Pop committed
1151
        if_val = ",if=%s" % cdrom_disk_type
Iustin Pop's avatar
Iustin Pop committed
1152
      drive_val = "file=%s%s%s" % (iso_image2, options, if_val)
Iustin Pop's avatar
Iustin Pop committed
1153
      kvm_cmd.extend(["-drive", drive_val])
1154
1155
1156

    floppy_image = hvp[constants.HV_KVM_FLOPPY_IMAGE_PATH]
    if floppy_image:
Iustin Pop's avatar
Iustin Pop committed
1157
      options = ",format=raw,media=disk"
1158
      if boot_floppy:
Iustin Pop's avatar
Iustin Pop committed
1159
1160
1161
1162
1163
1164
        kvm_cmd.extend(["-boot", "a"])
        options = "%s,boot=on" % options
      if_val = ",if=floppy"
      options = "%s%s" % (options, if_val)
      drive_val = "file=%s%s" % (floppy_image, options)
      kvm_cmd.extend(["-drive", drive_val])
1165

1166
    if kernel_path:
Iustin Pop's avatar
Iustin Pop committed
1167
      kvm_cmd.extend(["-kernel", kernel_path])
1168
      initrd_path = hvp[constants.HV_INITRD_PATH]
1169
      if initrd_path:
Iustin Pop's avatar
Iustin Pop committed
1170
1171
        kvm_cmd.extend(["-initrd", initrd_path])
      root_append = ["root=%s" % hvp[constants.HV_ROOT_PATH],
1172
1173
                     hvp[constants.HV_KERNEL_ARGS]]
      if hvp[constants.HV_SERIAL_CONSOLE]:
Guido Trotter's avatar
Guido Trotter committed
1174
1175
        serial_speed = hvp[constants.HV_SERIAL_SPEED]
        root_append.append("console=ttyS0,%s" % serial_speed)
Iustin Pop's avatar
Iustin Pop committed
1176
      kvm_cmd.extend(["-append", " ".join(root_append)])
Guido Trotter's avatar
Guido Trotter committed
1177

1178
1179
    mem_path = hvp[constants.HV_MEM_PATH]
    if mem_path:
1180
      kvm_cmd.extend(["-mem-path", mem_path, "-mem-prealloc"])
1181

1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
    monitor_dev = ("unix:%s,server,nowait" %
                   self._InstanceMonitor(instance.name))
    kvm_cmd.extend(["-monitor", monitor_dev])
    if hvp[constants.HV_SERIAL_CONSOLE]:
      serial_dev = ("unix:%s,server,nowait" %
                    self._InstanceSerial(instance.name))
      kvm_cmd.extend(["-serial", serial_dev])
    else:
      kvm_cmd.extend(["-serial", "none"])

1192
    mouse_type = hvp[constants.HV_USB_MOUSE]
1193
    vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]
1194
1195
    spice_bind = hvp[constants.HV_KVM_SPICE_BIND]
    spice_ip_version = None
1196

Guido Trotter's avatar
Guido Trotter committed
1197
1198
    kvm_cmd.extend(["-usb"])

1199
    if mouse_type:
Iustin Pop's avatar
Iustin Pop committed
1200
      kvm_cmd.extend(["-usbdevice", mouse_type])
1201
    elif vnc_bind_address:
Iustin Pop's avatar
Iustin Pop committed
1202
      kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
1203

1204
    if vnc_bind_address:
1205
      if netutils.IP4Address.IsValid(vnc_bind_address):
1206
1207
        if instance.network_port > constants.VNC_BASE_PORT:
          display = instance.network_port - constants.VNC_BASE_PORT
1208
          if vnc_bind_address == constants.IP4_ADDRESS_ANY:
Iustin Pop's avatar
Iustin Pop committed
1209
            vnc_arg = ":%d" % (display)
1210
          else:
Iustin Pop's avatar
Iustin Pop committed
1211
            vnc_arg = "%s:%d" % (vnc_bind_address, display)
1212
        else:
1213
          logging.error("Network port is not a valid VNC display (%d < %d)."
Iustin Pop's avatar
Iustin Pop committed
1214
1215
                        " Not starting VNC", instance.network_port,
                        constants.VNC_BASE_PORT)
Iustin Pop's avatar
Iustin Pop committed
1216
          vnc_arg = "none"
1217
1218
1219

        # Only allow tls and other option when not binding to a file, for now.
        # kvm/qemu gets confused otherwise about the filename to use.
Iustin Pop's avatar
Iustin Pop committed
1220
        vnc_append = ""
1221
        if hvp[constants.HV_VNC_TLS]:
Iustin Pop's avatar
Iustin Pop committed
1222
          vnc_append = "%s,tls" % vnc_append
1223
          if hvp[constants.HV_VNC_X509_VERIFY]:
Iustin Pop's avatar
Iustin Pop committed
1224
            vnc_append = "%s,x509verify=%s" % (vnc_append,
1225
1226
                                               hvp[constants.HV_VNC_X509])
          elif hvp[constants.HV_VNC_X509]:
Iustin Pop's avatar
Iustin Pop committed
1227
            vnc_append = "%s,x509=%s" % (vnc_append,
1228
                                         hvp[constants.HV_VNC_X509])
1229
        if hvp[constants.HV_VNC_PASSWORD_FILE]:
Iustin Pop's avatar
Iustin Pop committed
1230
          vnc_append = "%s,password" % vnc_append
1231

Iustin Pop's avatar
Iustin Pop committed
1232
        vnc_arg = "%s%s" % (vnc_arg, vnc_append)
1233

1234
      else:
Iustin Pop's avatar
Iustin Pop committed
1235
        vnc_arg = "unix:%s/%s.vnc" % (vnc_bind_address, instance.name)
1236

Iustin Pop's avatar
Iustin Pop committed
1237
      kvm_cmd.extend(["-vnc", vnc_arg])
1238
    elif spice_bind:
1239
1240
      # FIXME: this is wrong here; the iface ip address differs
      # between systems, so it should be done in _ExecuteKVMRuntime
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
      if netutils.IsValidInterface(spice_bind):
        # The user specified a network interface, we have to figure out the IP
        # address.
        addresses = netutils.GetInterfaceIpAddresses(spice_bind)
        spice_ip_version = hvp[constants.HV_KVM_SPICE_IP_VERSION]

        # if the user specified an IP version and the interface does not
        # have that kind of IP addresses, throw an exception
        if spice_ip_version != constants.IFACE_NO_IP_VERSION_SPECIFIED:
          if not addresses[spice_ip_version]:
            raise errors.HypervisorError("spice: unable to get an IPv%s address"
                                         " for %s" % (spice_ip_version,
                                                      spice_bind))

        # the user did not specify an IP version, we have to figure it out
        elif (addresses[constants.IP4_VERSION] and
              addresses[constants.IP6_VERSION]):
          # we have both ipv4 and ipv6, let's use the cluster default IP
          # version
          cluster_family = ssconf.SimpleStore().GetPrimaryIPFamily()
Michael Hanselmann's avatar
Michael Hanselmann committed
1261
1262
          spice_ip_version = \
            netutils.IPAddress.GetVersionFromAddressFamily(cluster_family)
1263
1264
        elif addresses[constants.IP4_VERSION]:
          spice_ip_version = constants.IP4_VERSION
1265
        elif addresses[constants.IP6_VERSION]:
1266
          spice_ip_version = constants.IP6_VERSION
1267
1268
1269