Synnefo » snf-ganeti

import copy

from bitarray import bitarray

try:

  import fdsend   # pylint: disable=F0401

except ImportError:

  nic_hotplug = False

FREE = bitarray("0")

def _GenerateDeviceKVMId(dev_type, dev):

  if not dev or not dev.pci:

    return None

  return "%s-pci-%d" % (dev_type.lower(), 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):

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

  try:

    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 == "NIC":

      found = [n for n in kvm_nics

               if n.uuid == dev.uuid]

    elif dev_type == "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 == "DISK":

      hvp = instance.hvparams

      security_model = hvparams[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):

    if self._TryHotplug(instance, dev_type):

      (kvm_cmd, kvm_nics, hvparams, \

        block_devices) = self._LoadKVMRuntime(instance)

      if action == "ADD":

        self._AnnotateFreePCISlot(instance, device)

        kvm_devid = _GenerateDeviceKVMId(dev_type, device)

        if dev_type == "DISK":

          self._HotAddDisk(instance,

                           device, extra, seq, kvm_devid, block_devices)

        elif dev_type == "NIC" and nic_hotplug:

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

      elif action == "REMOVE":

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

        if dev_type == "DISK":

          self._HotDelDisk(instance,

                           device, extra, seq, kvm_devid, block_devices)

        elif dev_type == "NIC" and nic_hotplug:

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

      self._SaveKVMRuntime(instance,

                          (kvm_cmd, kvm_nics, hvparams, block_devices))

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

    """Hotadd new disk to the VM

    """

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

    """Hotadd new nic to the VM

    """

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

    """Hotdel disk to the VM

    """

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

    """Hotadd new nic to the VM

    """

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

    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)