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

4
# Copyright (C) 2008, 2009, 2010, 2011 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
Guido Trotter's avatar
Guido Trotter committed
52
from ganeti.hypervisor import hv_base
53
from ganeti import netutils
54
from ganeti.utils import wrapper as utils_wrapper
Guido Trotter's avatar
Guido Trotter committed
55
56


57
_KVM_NETWORK_SCRIPT = constants.SYSCONFDIR + "/ganeti/kvm-vif-bridge"
58
_KVM_START_PAUSED_FLAG = "-S"
59

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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
# 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


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)

137

138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
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

    """
160
    return self.data.get(field_name, None)
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

  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):
183
184
    # The protocol expects the JSON object to be sent as a single line.
    return serializer.DumpJson(self.data)
185
186
187
188
189
190
191
192
193
194
195
196
197
198

  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"
199
200
  _RETURN_KEY = RETURN_KEY = "return"
  _ACTUAL_KEY = ACTUAL_KEY = "actual"
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
  _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 = ""

226
227
228
229
230
231
232
233
234
235
236
237
238
  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")

239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
  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

    """
257
258
259
260
261
262
263
264
265
266
    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")
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
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
    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
401
class KVMHypervisor(hv_base.BaseHypervisor):
Michael Hanselmann's avatar
Michael Hanselmann committed
402
403
404
  """KVM hypervisor interface

  """
405
  CAN_MIGRATE = True
Guido Trotter's avatar
Guido Trotter committed
406
407

  _ROOT_DIR = constants.RUN_GANETI_DIR + "/kvm-hypervisor"
Guido Trotter's avatar
Guido Trotter committed
408
  _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids
409
  _UIDS_DIR = _ROOT_DIR + "/uid" # contains instances reserved uids
Guido Trotter's avatar
Guido Trotter committed
410
411
  _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets
  _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
Balazs Lecz's avatar
Balazs Lecz committed
414
415
416
417
418
419
420
421
  # 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"
422
  _DIRS = [_ROOT_DIR, _PIDS_DIR, _UIDS_DIR, _CTRL_DIR, _CONF_DIR, _NICS_DIR,
Balazs Lecz's avatar
Balazs Lecz committed
423
           _CHROOT_DIR, _CHROOT_QUARANTINE_DIR]
Guido Trotter's avatar
Guido Trotter committed
424

425
426
427
428
429
430
431
  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,
Michael Hanselmann's avatar
Michael Hanselmann committed
432
    constants.HV_VNC_BIND_ADDRESS:
433
434
      (False, lambda x: (netutils.IP4Address.IsValid(x) or
                         utils.IsNormAbsPath(x)),
Michael Hanselmann's avatar
Michael Hanselmann committed
435
436
       "the VNC bind address must be either a valid IP address or an absolute"
       " pathname", None, None),
437
438
439
    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,
440
    constants.HV_VNC_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
441
442
443
444
445
446
    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),
447
    constants.HV_KVM_SPICE_PASSWORD_FILE: hv_base.OPT_FILE_CHECK,
448
449
450
451
452
453
454
455
456
457
458
459
460
    constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR:
      hv_base.ParamInSet(False,
        constants.HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS),
    constants.HV_KVM_SPICE_JPEG_IMG_COMPR:
      hv_base.ParamInSet(False,
        constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
    constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR:
      hv_base.ParamInSet(False,
        constants.HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS),
    constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION:
      hv_base.ParamInSet(False,
        constants.HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS),
    constants.HV_KVM_SPICE_AUDIO_COMPR: hv_base.NO_CHECK,
461
    constants.HV_KVM_SPICE_USE_TLS: hv_base.NO_CHECK,
462
463
    constants.HV_KVM_SPICE_TLS_CIPHERS: hv_base.NO_CHECK,
    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,
Michael Hanselmann's avatar
Michael Hanselmann committed
467
468
469
470
471
472
    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),
473
474
    constants.HV_KVM_CDROM_DISK_TYPE:
      hv_base.ParamInSet(False, constants.HT_KVM_VALID_DISK_TYPES),
Michael Hanselmann's avatar
Michael Hanselmann committed
475
476
    constants.HV_USB_MOUSE:
      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
480
    constants.HV_MIGRATION_BANDWIDTH: hv_base.NO_CHECK,
    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
484
    constants.HV_DISK_CACHE:
      hv_base.ParamInSet(True, constants.HT_VALID_CACHE_TYPES),
485
486
487
    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
488
489
    constants.HV_KVM_FLAG:
      hv_base.ParamInSet(False, constants.HT_KVM_FLAG_VALUES),
490
    constants.HV_VHOST_NET: hv_base.NO_CHECK,
Balazs Lecz's avatar
Balazs Lecz committed
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
495
      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
    constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,
496
    }
497

Iustin Pop's avatar
Iustin Pop committed
498
  _MIGRATION_STATUS_RE = re.compile("Migration\s+status:\s+(\w+)",
Guido Trotter's avatar
Guido Trotter committed
499
                                    re.M | re.I)
Michael Hanselmann's avatar
Michael Hanselmann committed
500
  _MIGRATION_PROGRESS_RE = \
501
502
503
    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)
504

505
506
  _MIGRATION_INFO_MAX_BAD_ANSWERS = 5
  _MIGRATION_INFO_RETRY_DELAY = 2
Guido Trotter's avatar
Guido Trotter committed
507

508
  _VERSION_RE = re.compile(r"\b(\d+)\.(\d+)(\.(\d+))?\b")
509

510
511
512
513
  _CPU_INFO_RE = re.compile(r"cpu\s+\#(\d+).*thread_id\s*=\s*(\d+)", re.I)
  _CPU_INFO_CMD = "info cpus"
  _CONT_CMD = "cont"

514
515
516
  ANCILLARY_FILES = [
    _KVM_NETWORK_SCRIPT,
    ]
517
518
519
  ANCILLARY_FILES_OPT = [
    _KVM_NETWORK_SCRIPT,
    ]
520

Guido Trotter's avatar
Guido Trotter committed
521
522
523
524
  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
525
    dirs = [(dname, constants.RUN_DIRS_MODE) for dname in self._DIRS]
Guido Trotter's avatar
Guido Trotter committed
526
    utils.EnsureDirs(dirs)
Guido Trotter's avatar
Guido Trotter committed
527

528
529
  @classmethod
  def _InstancePidFile(cls, instance_name):
530
531
532
    """Returns the instance pidfile.

    """
533
    return utils.PathJoin(cls._PIDS_DIR, instance_name)
534

535
536
537
538
539
540
541
  @classmethod
  def _InstanceUidFile(cls, instance_name):
    """Returns the instance uidfile.

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

542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
  @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
571
    arg_list = cmdline.split("\x00")
572
    while arg_list:
Michael Hanselmann's avatar
Michael Hanselmann committed
573
      arg = arg_list.pop(0)
574
575
576
577
578
579
580
581
582
583
584
585
586
      if arg == "-name":
        instance = arg_list.pop(0)
      elif arg == "-m":
        memory = int(arg_list.pop(0))
      elif arg == "-smp":
        vcpus = int(arg_list.pop(0))

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

    return (instance, memory, vcpus)

587
  def _InstancePidAlive(self, instance_name):
588
589
590
591
592
593
    """Returns the instance pidfile, pid, and liveness.

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

    """
596
    pidfile = self._InstancePidFile(instance_name)
597
    pid = utils.ReadPidFile(pidfile)
598
599
600
601
602
603
604

    alive = False
    try:
      cmd_instance = self._InstancePidInfo(pid)[0]
      alive = (cmd_instance == instance_name)
    except errors.HypervisorError:
      pass
605
606
607

    return (pidfile, pid, alive)

608
609
610
611
612
613
614
615
616
  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"))

617
618
  @classmethod
  def _InstanceMonitor(cls, instance_name):
619
620
621
    """Returns the instance monitor socket name

    """
622
    return utils.PathJoin(cls._CTRL_DIR, "%s.monitor" % instance_name)
623

624
625
  @classmethod
  def _InstanceSerial(cls, instance_name):
626
627
628
    """Returns the instance serial socket name

    """
629
    return utils.PathJoin(cls._CTRL_DIR, "%s.serial" % instance_name)
630

631
632
633
634
635
636
637
  @classmethod
  def _InstanceQmpMonitor(cls, instance_name):
    """Returns the instance serial QMP socket name

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

638
639
640
641
642
643
644
  @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.

    """
645
    if constants.SOCAT_USE_ESCAPE:
646
647
648
649
      return "raw,echo=0,escape=%s" % constants.SOCAT_ESCAPE_CODE
    else:
      return "echo=0,icanon=0"

650
651
  @classmethod
  def _InstanceKVMRuntime(cls, instance_name):
652
653
654
    """Returns the instance KVM runtime filename

    """
655
    return utils.PathJoin(cls._CONF_DIR, "%s.runtime" % instance_name)
656

Balazs Lecz's avatar
Balazs Lecz committed
657
658
659
660
661
662
663
  @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)

664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
  @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))

679
680
681
682
683
684
685
  @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)

686
687
688
689
690
691
692
  @classmethod
  def _TryReadUidFile(cls, uid_file):
    """Try to read a uid file

    """
    if os.path.exists(uid_file):
      try:
693
        uid = int(utils.ReadOneLineFile(uid_file))
694
        return uid
695
696
697
698
      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)
699
    return None
700

701
702
  @classmethod
  def _RemoveInstanceRuntimeFiles(cls, pidfile, instance_name):
Balazs Lecz's avatar
Balazs Lecz committed
703
    """Removes an instance's rutime sockets/files/dirs.
704
705
706
707
708

    """
    utils.RemoveFile(pidfile)
    utils.RemoveFile(cls._InstanceMonitor(instance_name))
    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
713
714
715
716
    uid_file = cls._InstanceUidFile(instance_name)
    uid = cls._TryReadUidFile(uid_file)
    utils.RemoveFile(uid_file)
    if uid is not None:
      uidpool.ReleaseUid(uid)
717
718
719
720
721
    try:
      shutil.rmtree(cls._InstanceNICDir(instance_name))
    except OSError, err:
      if err.errno != errno.ENOENT:
        raise
Balazs Lecz's avatar
Balazs Lecz committed
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
    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
740

741
  @staticmethod
742
743
  def _ConfigureNIC(instance, seq, nic, tap):
    """Run the network configuration script for a specified NIC
Guido Trotter's avatar
Guido Trotter committed
744
745
746
747
748
749
750

    @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
751
752
    @param tap: the host's tap interface this NIC corresponds to
    @type tap: str
Guido Trotter's avatar
Guido Trotter committed
753
754

    """
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
    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]

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

    result = utils.RunCmd([constants.KVM_IFUP, tap], env=env)
    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
784

785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
  @staticmethod
  def _VerifyAffinityPackage():
    if affinity is None:
      raise errors.HypervisorError("affinity Python package not"
        " found; cannot use CPU pinning under KVM")

  @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()
        affinity.set_process_affinity_mask(process_id,
          cls._BuildAffinityCpuMask(all_cpu_mapping))
    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],
          cls._BuildAffinityCpuMask(vcpu))

  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

869
870
  def _ExecuteCpuAffinity(self, instance_name, cpu_mask):
    """Complete CPU pinning.
871
872
873
874
875
876
877

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

    """
878
879
880
881
882
883
    # 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)
884

Guido Trotter's avatar
Guido Trotter committed
885
886
887
  def ListInstances(self):
    """Get the list of running instances.

Iustin Pop's avatar
Iustin Pop committed
888
889
    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
890
891
892
893

    """
    result = []
    for name in os.listdir(self._PIDS_DIR):
894
      if self._InstancePidAlive(name)[2]:
Guido Trotter's avatar
Guido Trotter committed
895
896
897
898
899
900
        result.append(name)
    return result

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

901
    @type instance_name: string
Iustin Pop's avatar
Iustin Pop committed
902
    @param instance_name: the instance name
903
904
    @rtype: tuple of strings
    @return: (name, id, memory, vcpus, stat, times)
Guido Trotter's avatar
Guido Trotter committed
905
906

    """
907
    _, pid, alive = self._InstancePidAlive(instance_name)
908
    if not alive:
Guido Trotter's avatar
Guido Trotter committed
909
910
      return None

911
    _, memory, vcpus = self._InstancePidInfo(pid)
912
    istat = "---b-"
Guido Trotter's avatar
Guido Trotter committed
913
914
    times = "0"

915
916
917
918
919
920
921
922
923
924
925
    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

926
    return (instance_name, pid, memory, vcpus, istat, times)
Guido Trotter's avatar
Guido Trotter committed
927
928
929
930

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

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

Guido Trotter's avatar
Guido Trotter committed
933
934
935
    """
    data = []
    for name in os.listdir(self._PIDS_DIR):
936
937
938
939
940
941
      try:
        info = self.GetInstanceInfo(name)
      except errors.HypervisorError:
        continue
      if info:
        data.append(info)
Guido Trotter's avatar
Guido Trotter committed
942
943
    return data

944
  def _GenerateKVMRuntime(self, instance, block_devices, startup_paused):
945
    """Generate KVM information to start an instance.
Guido Trotter's avatar
Guido Trotter committed
946
947

    """
948
    # pylint: disable=R0914,R0915
949
    _, v_major, v_min, _ = self._GetKVMVersion()
950

Michael Hanselmann's avatar
Michael Hanselmann committed
951
    pidfile = self._InstancePidFile(instance.name)
Guido Trotter's avatar
Guido Trotter committed
952
953
    kvm = constants.KVM_PATH
    kvm_cmd = [kvm]
954
    # used just by the vnc server, if enabled
Iustin Pop's avatar
Iustin Pop committed
955
    kvm_cmd.extend(["-name", instance.name])
956
    kvm_cmd.extend(["-m", instance.beparams[constants.BE_MAXMEM]])
Iustin Pop's avatar
Iustin Pop committed
957
958
    kvm_cmd.extend(["-smp", instance.beparams[constants.BE_VCPUS]])
    kvm_cmd.extend(["-pidfile", pidfile])
959
    kvm_cmd.extend(["-balloon", "virtio"])
Iustin Pop's avatar
Iustin Pop committed
960
    kvm_cmd.extend(["-daemonize"])
961
    if not instance.hvparams[constants.HV_ACPI]:
Iustin Pop's avatar
Iustin Pop committed
962
      kvm_cmd.extend(["-no-acpi"])
963
964
965
    if instance.hvparams[constants.HV_REBOOT_BEHAVIOR] == \
        constants.INSTANCE_REBOOT_EXIT:
      kvm_cmd.extend(["-no-reboot"])
Guido Trotter's avatar
Guido Trotter committed
966

967
    hvp = instance.hvparams
968
969
    boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK
    boot_cdrom = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_CDROM
970
    boot_floppy = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_FLOPPY
971
    boot_network = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_NETWORK
Guido Trotter's avatar
Guido Trotter committed
972

973
974
    self.ValidateParameters(hvp)

975
976
977
    if startup_paused:
      kvm_cmd.extend([_KVM_START_PAUSED_FLAG])

Guido Trotter's avatar
Guido Trotter committed
978
979
980
981
982
    if hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_ENABLED:
      kvm_cmd.extend(["-enable-kvm"])
    elif hvp[constants.HV_KVM_FLAG] == constants.HT_KVM_DISABLED:
      kvm_cmd.extend(["-disable-kvm"])

Guido Trotter's avatar
Guido Trotter committed
983
    if boot_network:
Iustin Pop's avatar
Iustin Pop committed
984
      kvm_cmd.extend(["-boot", "n"])
985

986
    disk_type = hvp[constants.HV_DISK_TYPE]
987
    if disk_type == constants.HT_DISK_PARAVIRTUAL:
Iustin Pop's avatar
Iustin Pop committed
988
      if_val = ",if=virtio"
989
    else:
Iustin Pop's avatar
Iustin Pop committed
990
      if_val = ",if=%s" % disk_type
991
992
    # Cache mode
    disk_cache = hvp[constants.HV_DISK_CACHE]
993
994
995
996
997
998
999
1000
    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:
1001
1002
1003
      cache_val = ",cache=%s" % disk_cache
    else:
      cache_val = ""
1004
    for cfdev, dev_path in block_devices:
1005
1006
1007
      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
1008
      # TODO: handle FD_LOOP and FD_BLKTAP (?)
1009
      boot_val = ""
1010
      if boot_disk:
Iustin Pop's avatar
Iustin Pop committed
1011
        kvm_cmd.extend(["-boot", "c"])
1012
        boot_disk = False
1013
1014
        if (v_major, v_min) < (0, 14) and disk_type != constants.HT_DISK_IDE:
          boot_val = ",boot=on"
Guido Trotter's avatar
Guido Trotter committed
1015

Iustin Pop's avatar
Iustin Pop committed
1016
      drive_val = "file=%s,format=raw%s%s%s" % (dev_path, if_val, boot_val,
1017
                                                cache_val)
Iustin Pop's avatar
Iustin Pop committed
1018
      kvm_cmd.extend(["-drive", drive_val])
Guido Trotter's avatar
Guido Trotter committed
1019

1020
1021
1022
1023
1024
    #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

1025
    iso_image = hvp[constants.HV_CDROM_IMAGE_PATH]
1026
    if iso_image:
Iustin Pop's avatar
Iustin Pop committed
1027
      options = ",format=raw,media=cdrom"
1028
      if boot_cdrom:
Iustin Pop's avatar
Iustin Pop committed
1029
        kvm_cmd.extend(["-boot", "d"])
1030
        if cdrom_disk_type != constants.HT_DISK_IDE:
Iustin Pop's avatar
Iustin Pop committed
1031
          options = "%s,boot=on,if=%s" % (options, constants.HT_DISK_IDE)
1032
        else:
Iustin Pop's avatar
Iustin Pop committed
1033
          options = "%s,boot=on" % options
1034
      else:
1035
        if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
Iustin Pop's avatar
Iustin Pop committed
1036
          if_val = ",if=virtio"
1037
        else:
Iustin Pop's avatar
Iustin Pop committed
1038
1039
1040
1041
          if_val = ",if=%s" % cdrom_disk_type
        options = "%s%s" % (options, if_val)
      drive_val = "file=%s%s" % (iso_image, options)
      kvm_cmd.extend(["-drive", drive_val])
1042

1043
1044
    iso_image2 = hvp[constants.HV_KVM_CDROM2_IMAGE_PATH]
    if iso_image2:
Iustin Pop's avatar
Iustin Pop committed
1045
      options = ",format=raw,media=cdrom"
1046
      if cdrom_disk_type == constants.HT_DISK_PARAVIRTUAL:
Iustin Pop's avatar
Iustin Pop committed
1047
        if_val = ",if=virtio"
1048
      else:
Iustin Pop's avatar
Iustin Pop committed
1049
1050
1051
1052
        if_val = ",if=%s" % cdrom_disk_type
      options = "%s%s" % (options, if_val)
      drive_val = "file=%s%s" % (iso_image2, options)
      kvm_cmd.extend(["-drive", drive_val])
1053
1054
1055

    floppy_image = hvp[constants.HV_KVM_FLOPPY_IMAGE_PATH]
    if floppy_image:
Iustin Pop's avatar
Iustin Pop committed
1056
      options = ",format=raw,media=disk"
1057
      if boot_floppy:
Iustin Pop's avatar
Iustin Pop committed
1058
1059
1060
1061
1062
1063
        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])
1064

1065
    kernel_path = hvp[constants.HV_KERNEL_PATH]
1066
    if kernel_path:
Iustin Pop's avatar
Iustin Pop committed
1067
      kvm_cmd.extend(["-kernel", kernel_path])
1068
      initrd_path = hvp[constants.HV_INITRD_PATH]
1069
      if initrd_path:
Iustin Pop's avatar
Iustin Pop committed
1070
1071
        kvm_cmd.extend(["-initrd", initrd_path])
      root_append = ["root=%s" % hvp[constants.HV_ROOT_PATH],
1072
1073
                     hvp[constants.HV_KERNEL_ARGS]]
      if hvp[constants.HV_SERIAL_CONSOLE]:
Iustin Pop's avatar
Iustin Pop committed
1074
1075
        root_append.append("console=ttyS0,38400")
      kvm_cmd.extend(["-append", " ".join(root_append)])
Guido Trotter's avatar
Guido Trotter committed
1076

1077
1078
    mem_path = hvp[constants.HV_MEM_PATH]
    if mem_path:
1079
      kvm_cmd.extend(["-mem-path", mem_path, "-mem-prealloc"])
1080

1081
    mouse_type = hvp[constants.HV_USB_MOUSE]
1082
1083
    vnc_bind_address = hvp[constants.HV_VNC_BIND_ADDRESS]

1084
    if mouse_type:
Iustin Pop's avatar
Iustin Pop committed
1085
1086
      kvm_cmd.extend(["-usb"])
      kvm_cmd.extend(["-usbdevice", mouse_type])
1087
    elif vnc_bind_address:
Iustin Pop's avatar
Iustin Pop committed
1088
      kvm_cmd.extend(["-usbdevice", constants.HT_MOUSE_TABLET])
1089

1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
    keymap = hvp[constants.HV_KEYMAP]
    if keymap:
      keymap_path = self._InstanceKeymapFile(instance.name)
      # If a keymap file is specified, KVM won't use its internal defaults. By
      # first including the "en-us" layout, an error on loading the actual
      # layout (e.g. because it can't be found) won't lead to a non-functional
      # keyboard. A keyboard with incorrect keys is still better than none.
      utils.WriteFile(keymap_path, data="include en-us\ninclude %s\n" % keymap)
      kvm_cmd.extend(["-k", keymap_path])

1100
    if vnc_bind_address:
1101
      if netutils.IP4Address.IsValid(vnc_bind_address):
1102
1103
        if instance.network_port > constants.VNC_BASE_PORT:
          display = instance.network_port - constants.VNC_BASE_PORT
1104
          if vnc_bind_address == constants.IP4_ADDRESS_ANY:
Iustin Pop's avatar
Iustin Pop committed
1105
            vnc_arg = ":%d" % (display)
1106
          else:
Iustin Pop's avatar
Iustin Pop committed
1107
            vnc_arg = "%s:%d" % (vnc_bind_address, display)
1108
        else:
1109
          logging.error("Network port is not a valid VNC display (%d < %d)."
Iustin Pop's avatar
Iustin Pop committed
1110
1111
                        " Not starting VNC", instance.network_port,
                        constants.VNC_BASE_PORT)
Iustin Pop's avatar
Iustin Pop committed
1112
          vnc_arg = "none"
1113
1114
1115

        # 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
1116
        vnc_append = ""
1117
        if hvp[constants.HV_VNC_TLS]:
Iustin Pop's avatar
Iustin Pop committed
1118
          vnc_append = "%s,tls" % vnc_append
1119
          if hvp[constants.HV_VNC_X509_VERIFY]:
Iustin Pop's avatar
Iustin Pop committed
1120
            vnc_append = "%s,x509verify=%s" % (vnc_append,
1121
1122
                                               hvp[constants.HV_VNC_X509])
          elif hvp[constants.HV_VNC_X509]:
Iustin Pop's avatar
Iustin Pop committed
1123
            vnc_append = "%s,x509=%s" % (vnc_append,
1124
                                         hvp[constants.HV_VNC_X509])
1125
        if hvp[constants.HV_VNC_PASSWORD_FILE]:
Iustin Pop's avatar
Iustin Pop committed
1126
          vnc_append = "%s,password" % vnc_append
1127

Iustin Pop's avatar
Iustin Pop committed
1128
        vnc_arg = "%s%s" % (vnc_arg, vnc_append)
1129

1130
      else:
Iustin Pop's avatar
Iustin Pop committed
1131
        vnc_arg = "unix:%s/%s.vnc" % (vnc_bind_address, instance.name)
1132

Iustin Pop's avatar
Iustin Pop committed
1133
      kvm_cmd.extend(["-vnc", vnc_arg])
1134
    else:
Iustin Pop's avatar
Iustin Pop committed
1135
      kvm_cmd.extend(["-nographic"])
1136

1137
1138
    monitor_dev = ("unix:%s,server,nowait" %
                   self._InstanceMonitor(instance.name))
Iustin Pop's avatar
Iustin Pop committed
1139
    kvm_cmd.extend(["-monitor", monitor_dev])
1140
    if hvp[constants.HV_SERIAL_CONSOLE]:
Iustin Pop's avatar
Iustin Pop committed
1141
      serial_dev = ("unix:%s,server,nowait" %
1142
                    self._InstanceSerial(instance.name))
Iustin Pop's avatar
Iustin Pop committed
1143
      kvm_cmd.extend(["-serial", serial_dev])
1144
    else:
Iustin Pop's avatar
Iustin Pop committed
1145
      kvm_cmd.extend(["-serial", "none"])
Guido Trotter's avatar
Guido Trotter committed
1146

1147
    spice_bind = hvp[constants.HV_KVM_SPICE_BIND]
1148
    spice_ip_version = None
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
    if spice_bind:
      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
1170
1171
          spice_ip_version = \
            netutils.IPAddress.GetVersionFromAddressFamily(cluster_family)
1172
1173
        elif addresses[constants.IP4_VERSION]:
          spice_ip_version = constants.IP4_VERSION
1174
        elif addresses[constants.IP6_VERSION]:
1175
          spice_ip_version = constants.IP6_VERSION
1176
1177
1178
        else:
          raise errors.HypervisorError("spice: unable to get an IP address"
                                       " for %s" % (spice_bind))
1179
1180
1181
1182
1183
1184
1185
1186

        spice_address = addresses[spice_ip_version][0]

      else:
        # spice_bind is known to be a valid IP address, because
        # ValidateParameters checked it.
        spice_address = spice_bind

1187
1188
1189
1190
1191
1192
      spice_arg = "addr=%s" % spice_address
      if hvp[constants.HV_KVM_SPICE_USE_TLS]:
        spice_arg = "%s,tls-port=%s,x509-cacert-file=%s" % (spice_arg,
            instance.network_port, constants.SPICE_CACERT_FILE)
        spice_arg = "%s,x509-key-file=%s,x509-cert-file=%s" % (spice_arg,
            constants.SPICE_CERT_FILE, constants.SPICE_CERT_FILE)
1193
1194
1195
        tls_ciphers = hvp[constants.HV_KVM_SPICE_TLS_CIPHERS]
        if tls_ciphers:
          spice_arg = "%s,tls-ciphers=%s" % (spice_arg, tls_ciphers)
1196
1197
1198
      else:
        spice_arg = "%s,port=%s" % (spice_arg, instance.network_port)

1199
1200
1201
      if not hvp[constants.HV_KVM_SPICE_PASSWORD_FILE]:
        spice_arg = "%s,disable-ticketing" % spice_arg

1202
1203
      if spice_ip_version:
        spice_arg = "%s,ipv%s" % (spice_arg, spice_ip_version)
1204

1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
      # Image compression options
      img_lossless = hvp[constants.HV_KVM_SPICE_LOSSLESS_IMG_COMPR]
      img_jpeg = hvp[constants.HV_KVM_SPICE_JPEG_IMG_COMPR]
      img_zlib_glz = hvp[constants.HV_KVM_SPICE_ZLIB_GLZ_IMG_COMPR]
      if img_lossless:
        spice_arg = "%s,image-compression=%s" % (spice_arg, img_lossless)
      if img_jpeg:
        spice_arg = "%s,jpeg-wan-compression=%s" % (spice_arg, img_jpeg)
      if img_zlib_glz:
        spice_arg = "%s,zlib-glz-wan-compression=%s" % (spice_arg, img_zlib_glz)

      # Video stream detection
      video_streaming = hvp[constants.HV_KVM_SPICE_STREAMING_VIDEO_DETECTION]
      if video_streaming:
        spice_arg = "%s,streaming-video=%s" % (spice_arg, video_streaming)

      # Audio compression, by default in qemu-kvm it is on
      if not hvp[constants.HV_KVM_SPICE_AUDIO_COMPR]:
        spice_arg = "%s,playback-compression=off" % spice_arg
1224
1225
      if not hvp[constants.HV_KVM_SPICE_USE_VDAGENT]:
        spice_arg = "%s,agent-mouse=off" % spice_arg
1226

1227
1228
1229
      logging.info("KVM: SPICE will listen on port %s", instance.network_port)
      kvm_cmd.extend(["-spice", spice_arg])

1230
1231
1232
      # Tell kvm to use the paravirtualized graphic card, optimized for SPICE
      kvm_cmd.extend(["-vga", "qxl"])

1233
    if hvp[constants.HV_USE_LOCALTIME]:
Iustin Pop's avatar
Iustin Pop committed
1234
      kvm_cmd.extend(["-localtime"])
1235

Balazs Lecz's avatar
Balazs Lecz committed
1236
    if hvp[constants.HV_KVM_USE_CHROOT]:
Iustin Pop's avatar
Iustin Pop committed
1237
      kvm_cmd.extend(["-chroot", self._InstanceChrootDir(instance.name)])
Balazs Lecz's avatar
Balazs Lecz committed
1238

1239
1240
1241
    # Save the current instance nics, but defer their expansion as parameters,
    # as we'll need to generate executable temp files for them.
    kvm_nics = instance.nics
1242
    hvparams = hvp
1243

1244
    return (kvm_cmd, kvm_nics, hvparams)
1245

1246
1247
1248
1249
1250
1251
1252
  def _WriteKVMRuntime(self, instance_name, data):
    """Write an instance's KVM runtime

    """
    try:
      utils.WriteFile(self._InstanceKVMRuntime(instance_name),
                      data=data)
1253
    except EnvironmentError, err:
1254
1255
1256
1257
1258
1259
1260
1261
      raise errors.HypervisorError("Failed to save KVM runtime file: %s" % err)

  def _ReadKVMRuntime(self, instance_name):
    """Read an instance's KVM runtime

    """
    try:
      file_content = utils.ReadFile(self._InstanceKVMRuntime(instance_name))
1262
    except EnvironmentError, err:
1263
1264
1265
1266
1267
1268
1269
      raise errors.HypervisorError("Failed to load KVM runtime file: %s" % err)
    return file_content

  def _SaveKVMRuntime(self, instance, kvm_runtime):
    """Save an instance's KVM runtime

    """
1270
    kvm_cmd, kvm_nics, hvparams = kvm_runtime
1271
    serialized_nics = [nic.ToDict() for nic in kvm_nics]
1272
    serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams))
1273
1274
    self._WriteKVMRuntime(instance.name, serialized_form)

Guido Trotter's avatar
Guido Trotter committed
1275
  def _LoadKVMRuntime(self, instance, serialized_runtime=None):
1276
1277
1278
    """Load an instance's KVM runtime

    """