Synnefo » snf-ganeti » ganeti-local

import copy

from bitarray import bitarray

try:

  import fdsend   # pylint: disable=F0401

except ImportError:

  fdsend = None

FREE = bitarray("0")

def _GenerateDeviceKVMId(dev_type, dev):

  if not dev or not dev.pci:

    return None

  return "%s-%s-pci-%d" % (dev_type.lower(), dev.uuid.split("-")[0], dev.pci)

def _UpdatePCISlots(dev, pci_reservations):

  """Update pci configuration for a stopped instance

  If dev has a pci slot the reserve it, else find first available.

  """

  if dev.pci:

    free = dev.pci

  else:

    [free] = pci_reservations.search(FREE, 1) # pylint: disable=E1103

    if not free:

      raise errors.HypervisorError("All PCI slots occupied")

    dev.pci = int(free)

  pci_reservations[free] = True

def _RemoveFromRuntimeEntry(devices, device, fn):

  try:

    [rem] = [x for x in fn(devices) if x.uuid == device.uuid]

    devices.remove(rem)

  except (ValueError, IndexError):

    logging.info("No device with uuid %s in runtime file", device.uuid)

  _INFO_PCI_RE = re.compile(r'Bus.*device[ ]*(\d+).*')

  _INFO_PCI_CMD = "info pci"

  _INFO_VERSION_RE = \

    re.compile(r'^QEMU (\d+)\.(\d+)(\.(\d+))?.*monitor.*', re.M)

  _INFO_VERSION_CMD = "info version"

  _DEFAULT_PCI_RESERVATIONS = "11110000000000000000000000000000"

  def _GetExistingDeviceKVMId(self, instance, dev_type, dev):

    (_, kvm_nics, __, block_devices) = self._LoadKVMRuntime(instance)

    if dev_type == constants.HOTPLUG_NIC:

      found = [n for n in kvm_nics

               if n.uuid == dev.uuid]

    elif dev_type == constants.HOTPLUG_DISK:

      found = [d for d, _ in block_devices

               if d.uuid == dev.uuid]

    dev_info = None

    if found:

      dev_info = found[0]

    return _GenerateDeviceKVMId(dev_type, dev_info)

  def _GenerateKVMBlockDevicesOptions(self, instance, kvm_cmd, block_devices,

                                      pci_reservations, kvmhelp):

    hvp = instance.hvparams

    boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK

    # whether this is an older KVM version that uses the boot=on flag

    # on devices

    needs_boot_flag = self._BOOT_RE.search(kvmhelp)

    disk_type = hvp[constants.HV_DISK_TYPE]

    if disk_type == constants.HT_DISK_PARAVIRTUAL:

      #TODO: parse kvm -device ? output

      disk_model = "virtio-blk-pci"

      if_val = ",if=virtio"

    else:

      if_val = ",if=%s" % disk_type

    # Cache mode

    disk_cache = hvp[constants.HV_DISK_CACHE]

    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:

      cache_val = ",cache=%s" % disk_cache

    else:

      cache_val = ""

    for cfdev, dev_path in block_devices:

      if cfdev.mode != constants.DISK_RDWR:

        raise errors.HypervisorError("Instance has read-only disks which"

                                     " are not supported by KVM")

      # TODO: handle FD_LOOP and FD_BLKTAP (?)

      boot_val = ""

      if boot_disk:

        kvm_cmd.extend(["-boot", "c"])

        boot_disk = False

        if needs_boot_flag and disk_type != constants.HT_DISK_IDE:

          boot_val = ",boot=on"

      drive_val = "file=%s,format=raw%s%s" % \

                  (dev_path, boot_val, cache_val)

      _UpdatePCISlots(cfdev, pci_reservations)

      kvm_devid = _GenerateDeviceKVMId("DISK", cfdev)

      if kvm_devid:

        #TODO: name id after model

        drive_val += (",if=none,id=%s" % kvm_devid)

        drive_val += (",bus=0,unit=%d" % cfdev.pci)

      else:

        drive_val += if_val

      kvm_cmd.extend(["-drive", drive_val])

      if kvm_devid:

        dev_val = ("%s,drive=%s,id=%s" %

                    (disk_model, kvm_devid, kvm_devid))

        dev_val += ",bus=pci.0,addr=%s" % hex(cfdev.pci)

        kvm_cmd.extend(["-device", dev_val])

    return kvm_cmd

      boot_cdrom = boot_floppy = boot_network = False

    return (kvm_cmd, kvm_nics, hvparams, block_devices)

    kvm_cmd, kvm_nics, hvparams, block_devices = kvm_runtime

    serialized_blockdevs = [(blk.ToDict(), link) for blk, link in block_devices]

    serialized_form = serializer.Dump((kvm_cmd, serialized_nics, hvparams,

                                      serialized_blockdevs))

    if len(loaded_runtime)==3:

      serialized_blockdevs = []

      kvm_cmd, serialized_nics, hvparams = loaded_runtime

    else:

      kvm_cmd, serialized_nics, hvparams, serialized_blockdevs = loaded_runtime

    block_devices = [(objects.Disk.FromDict(sdisk), link)

                     for sdisk, link in serialized_blockdevs]

    return (kvm_cmd, kvm_nics, hvparams, block_devices)

  # pylint: disable=R0914

    kvm_cmd, kvm_nics, up_hvp, block_devices = kvm_runtime

    kvm_cmd_runtime = copy.deepcopy(kvm_cmd)

    pci_reservations = bitarray(self._DEFAULT_PCI_RESERVATIONS)

    kvm_cmd = self._GenerateKVMBlockDevicesOptions(instance, kvm_cmd,

                                                   block_devices,

                                                   pci_reservations,

                                                   kvmhelp)

          nic_val = "%s,mac=%s" % (nic_model, nic.mac)

          _UpdatePCISlots(nic, pci_reservations)

          kvm_devid = _GenerateDeviceKVMId("NIC", nic)

          netdev = kvm_devid or "netdev%d" % nic_seq

          nic_val += (",netdev=%s" % netdev)

          if kvm_devid:

            nic_val += (",id=%s,bus=pci.0,addr=%s" % (kvm_devid, hex(nic.pci)))

          tap_val = ("type=tap,id=%s,fd=%d%s" %

                     (netdev, tapfd, tap_extra))

    kvm_runtime_with_pci_info = (kvm_cmd_runtime, kvm_nics,

                                 up_hvp, block_devices)

    return kvm_runtime_with_pci_info

    kvm_runtime_with_pci_info = self._ExecuteKVMRuntime(instance, kvm_runtime,

                                                        kvmhelp)

    self._SaveKVMRuntime(instance, kvm_runtime_with_pci_info)

  def _AnnotateFreePCISlot(self, instance, dev):

    """Get the first available pci slot of a runnung instance.

    """

    slots = bitarray(32)

    slots.setall(False) # pylint: disable=E1101

    output = self._CallMonitorCommand(instance.name, self._INFO_PCI_CMD)

    for line in output.stdout.splitlines():

      match = self._INFO_PCI_RE.search(line)

      if match:

        slot = int(match.group(1))

        slots[slot] = True

    [free] = slots.search(FREE, 1) # pylint: disable=E1101

    if not free:

      raise errors.HypervisorError("All PCI slots occupied")

    dev.pci = int(free)

  def _TryHotplug(self, instance, dev_type):

    """Get QEMU version from the instance's monitor.

    Hotplug is supported for running instances and for versions >= 1.0.

    """

    if dev_type == constants.HOTPLUG_DISK:

      hvp = instance.hvparams

      security_model = hvp[constants.HV_SECURITY_MODEL]

      use_chroot = hvp[constants.HV_KVM_USE_CHROOT]

      if use_chroot or security_model != constants.HT_SM_NONE:

        return False

    output = self._CallMonitorCommand(instance.name, self._INFO_VERSION_CMD)

    #TODO: search for netdev_add, drive_add, device_add.....

    match = self._INFO_VERSION_RE.search(output.stdout)

    if not match:

      return False

    v_major, v_min, _, _ = match.groups()

    return (v_major, v_min) >= (1, 0)

  def _CallMonitorHotplugCommand(self, name, cmd):

    output = self._CallMonitorCommand(name, cmd)

    #TODO: parse output and check if succeeded

    for line in output.stdout.splitlines():

      logging.info("%s", line)

  def HotplugDevice(self, instance, action, dev_type, device, extra, seq):

    """ Generic method to hotplug device

    Depending on action and dev_type invoke the coresponding method that

    does the actual hotplug (via KVM monitor commands).

    Before and after, do all hotplug related steps (e.g. check if hotplug

    is possible, annotate pci slot to device and generate/get existing

    KVM device ids, read/write runtime file)

    """

    if self._TryHotplug(instance, dev_type):

      (kvm_cmd, kvm_nics, hvparams, \

        block_devices) = self._LoadKVMRuntime(instance)

      if action == constants.HOTPLUG_ADD:

        self._AnnotateFreePCISlot(instance, device)

        kvm_devid = _GenerateDeviceKVMId(dev_type, device)

        if dev_type == constants.HOTPLUG_DISK:

          self._HotAddDisk(instance,

                           device, extra, seq, kvm_devid, block_devices)

        elif dev_type == constants.HOTPLUG_NIC and fdsend:

          self._HotAddNic(instance, device, extra, seq, kvm_devid, kvm_nics)

      elif action == constants.HOTPLUG_REMOVE:

        kvm_devid = self._GetExistingDeviceKVMId(instance, dev_type, device)

        if dev_type == constants.HOTPLUG_DISK:

          self._HotDelDisk(instance,

                           device, extra, seq, kvm_devid, block_devices)

        elif dev_type == constants.HOTPLUG_NIC and fdsend:

          self._HotDelNic(instance, device, extra, seq, kvm_devid, kvm_nics)

      self._SaveKVMRuntime(instance,

                          (kvm_cmd, kvm_nics, hvparams, block_devices))

      time.sleep(2)

  def _HotAddDisk(self, instance, disk, dev_path, _, kvm_devid, block_devices):

    """Hotplug/add new disk to and instance

    """

    command = ("drive_add dummy file=%s,if=none,id=%s,format=raw" %

               (dev_path, kvm_devid))

    self._CallMonitorHotplugCommand(instance.name, command)

    command = ("device_add virtio-blk-pci,bus=pci.0,addr=%s,"

               "drive=%s,id=%s"

               % (hex(disk.pci), kvm_devid, kvm_devid))

    self._CallMonitorHotplugCommand(instance.name, command)

    block_devices.append((disk, dev_path))

  def _HotAddNic(self, instance, nic, _, seq, kvm_devid, kvm_nics):

    """Hotplug/add nic to an instance

    """

    (tap, fd) = _OpenTap()

    self._PassTapFd(instance, fd, nic)

    command = ("netdev_add tap,id=%s,fd=%s" % (kvm_devid, kvm_devid))

    self._CallMonitorHotplugCommand(instance.name, command)

    command = ("device_add virtio-net-pci,bus=pci.0,addr=%s,mac=%s,"

               "netdev=%s,id=%s"

               % (hex(nic.pci), nic.mac, kvm_devid, kvm_devid))

    self._CallMonitorHotplugCommand(instance.name, command)

    self._ConfigureNIC(instance, seq, nic, tap)

    utils.WriteFile(self._InstanceNICFile(instance.name, seq), data=tap)

    kvm_nics.append(nic)

  def _HotDelDisk(self, instance, disk, _, __, kvm_devid, block_devices):

    """Hotplug/remove disk from an instance

    """

    command = "device_del %s" % kvm_devid

    self._CallMonitorHotplugCommand(instance.name, command)

    #command = "drive_del %s" % uuid

    #self._CallMonitorHotplugCommand(instance.name, command)

    _RemoveFromRuntimeEntry(block_devices, disk, lambda x: [d for d, l in x])

  def _HotDelNic(self, instance, nic, _, __, kvm_devid, kvm_nics):

    """Hotplug/remove existing nic from an instance

    """

    command = "device_del %s" % kvm_devid

    self._CallMonitorHotplugCommand(instance.name, command)

    command = "netdev_del %s" % kvm_devid

    self._CallMonitorHotplugCommand(instance.name, command)

    _RemoveFromRuntimeEntry(kvm_nics, nic, lambda x: x)

  def _PassTapFd(self, instance, fd, nic):

    """Pass file descriptor to kvm process via monitor socket using SCM_RIGHTS

    """

    monsock = utils.ShellQuote(self._InstanceMonitor(instance.name))

    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

    s.connect(monsock)

    kvm_devid = _GenerateDeviceKVMId("NIC", nic)

    command = "getfd %s\n" % kvm_devid

    fds = [fd]

    logging.info("%s", fds)

    fdsend.sendfds(s, command, fds = fds)

    s.close()

    kvm_runtime_with_pci_info = \

      self._ExecuteKVMRuntime(instance, kvm_runtime, kvmhelp)

    self._SaveKVMRuntime(instance, kvm_runtime_with_pci_info)