Merge "pci: Add vDPA vnic to PCI request mapping and filtering"

Author: Zuul

nova/objects/pci_device.py

@@ -354,7 +354,9 @@ def claim(self, instance_uuid):
             self._bulk_update_status(vfs_list,
                                            fields.PciDeviceStatus.UNCLAIMABLE)
 
-        elif self.dev_type == fields.PciDeviceType.SRIOV_VF:
+        elif self.dev_type in (
+            fields.PciDeviceType.SRIOV_VF, fields.PciDeviceType.VDPA
+        ):
             # Update VF status to CLAIMED if it's parent has not been
             # previously allocated or claimed
             # When claiming/allocating a VF, it's parent PF becomes
@@ -414,7 +416,9 @@ def allocate(self, instance):
             self._bulk_update_status(vfs_list,
                                      fields.PciDeviceStatus.UNAVAILABLE)
 
-        elif (self.dev_type == fields.PciDeviceType.SRIOV_VF):
+        elif self.dev_type in (
+            fields.PciDeviceType.SRIOV_VF, fields.PciDeviceType.VDPA
+        ):
             parent = self.parent_device
             if parent:
                 if parent.status not in parent_ok_statuses:
@@ -473,7 +477,9 @@ def free(self, instance=None):
             self._bulk_update_status(vfs_list,
                                      fields.PciDeviceStatus.AVAILABLE)
             free_devs.extend(vfs_list)
-        if self.dev_type == fields.PciDeviceType.SRIOV_VF:
+        if self.dev_type in (
+            fields.PciDeviceType.SRIOV_VF, fields.PciDeviceType.VDPA
+        ):
             # Set PF status to AVAILABLE if all of it's VFs are free
             parent = self.parent_device
             if not parent:

nova/pci/manager.py

@@ -189,7 +189,9 @@ def _build_device_tree(all_devs):
             if dev.dev_type == fields.PciDeviceType.SRIOV_PF:
                 dev.child_devices = []
                 parents[dev.address] = dev
-            elif dev.dev_type == fields.PciDeviceType.SRIOV_VF:
+            elif dev.dev_type in (
+                fields.PciDeviceType.SRIOV_VF, fields.PciDeviceType.VDPA
+            ):
                 dev.parent_device = parents.get(dev.parent_addr)
                 if dev.parent_device:
                     parents[dev.parent_addr].child_devices.append(dev)

nova/pci/request.py

@@ -56,7 +56,8 @@
 PCI_DEVICE_TYPE_TAG = 'dev_type'
 
 DEVICE_TYPE_FOR_VNIC_TYPE = {
-    network_model.VNIC_TYPE_DIRECT_PHYSICAL: obj_fields.PciDeviceType.SRIOV_PF
+    network_model.VNIC_TYPE_DIRECT_PHYSICAL: obj_fields.PciDeviceType.SRIOV_PF,
+    network_model.VNIC_TYPE_VDPA: obj_fields.PciDeviceType.VDPA,
 }
 
 CONF = nova.conf.CONF

nova/pci/stats.py

@@ -217,15 +217,18 @@ def _handle_device_dependents(self, pci_dev):
 
         In case the device is a PF, all of it's dependent VFs should
         be removed from pools count, if these are present.
-        When the device is a VF, it's parent PF pool count should be
-        decreased, unless it is no longer in a pool.
+        When the device is a VF, or a VDPA device, it's parent PF
+        pool count should be decreased, unless it is no longer in a pool.
         """
         if pci_dev.dev_type == fields.PciDeviceType.SRIOV_PF:
             vfs_list = pci_dev.child_devices
             if vfs_list:
                 for vf in vfs_list:
                     self.remove_device(vf)
-        elif pci_dev.dev_type == fields.PciDeviceType.SRIOV_VF:
+        elif pci_dev.dev_type in (
+            fields.PciDeviceType.SRIOV_VF,
+            fields.PciDeviceType.VDPA,
+        ):
             try:
                 parent = pci_dev.parent_device
                 # Make sure not to decrease PF pool count if this parent has
@@ -387,6 +390,28 @@ def _filter_pools_for_unrequested_pfs(self, pools, request):
             ]
         return pools
 
+    def _filter_pools_for_unrequested_vdpa_devices(self, pools, request):
+        """Filter out pools with VDPA devices, unless these are required.
+
+        This is necessary as vdpa devices require special handling and
+        should not be allocated to generic pci device requests.
+
+        :param pools: A list of PCI device pool dicts
+        :param request: An InstancePCIRequest object describing the type,
+            quantity and required NUMA affinity of device(s) we want.
+        :returns: A list of pools that can be used to support the request if
+            this is possible.
+        """
+        if all(
+            spec.get('dev_type') != fields.PciDeviceType.VDPA
+            for spec in request.spec
+        ):
+            pools = [
+                pool for pool in pools
+                if not pool.get('dev_type') == fields.PciDeviceType.VDPA
+            ]
+        return pools
+
     def _filter_pools(self, pools, request, numa_cells):
         """Determine if an individual PCI request can be met.
 
@@ -421,7 +446,7 @@ def _filter_pools(self, pools, request, numa_cells):
             )
 
         if after_count < request.count:
-            LOG.debug('Not enough PCI devices left to satify request')
+            LOG.debug('Not enough PCI devices left to satisfy request')
             return None
 
         # Next, let's exclude all devices that aren't on the correct NUMA node
@@ -438,10 +463,10 @@ def _filter_pools(self, pools, request, numa_cells):
             )
 
         if after_count < request.count:
-            LOG.debug('Not enough PCI devices left to satify request')
+            LOG.debug('Not enough PCI devices left to satisfy request')
             return None
 
-        # Finally, if we're not requesting PFs then we should not use these.
+        # If we're not requesting PFs then we should not use these.
         # Exclude them.
         before_count = after_count
         pools = self._filter_pools_for_unrequested_pfs(pools, request)
@@ -455,7 +480,24 @@ def _filter_pools(self, pools, request, numa_cells):
             )
 
         if after_count < request.count:
-            LOG.debug('Not enough PCI devices left to satify request')
+            LOG.debug('Not enough PCI devices left to satisfy request')
+            return None
+
+        # If we're not requesting VDPA devices then we should not use these
+        # either. Exclude them.
+        before_count = after_count
+        pools = self._filter_pools_for_unrequested_vdpa_devices(pools, request)
+        after_count = sum([pool['count'] for pool in pools])
+
+        if after_count < before_count:
+            LOG.debug(
+                'Dropped %d devices as they are VDPA devices which we have '
+                'not requested',
+                before_count - after_count
+            )
+
+        if after_count < request.count:
+            LOG.debug('Not enough PCI devices left to satisfy request')
             return None
 
         return pools

nova/tests/unit/network/test_neutron.py

@@ -5772,7 +5772,8 @@ def test_create_resource_requests(self, getclient,
                 objects.NetworkRequest(port_id=uuids.portid_3),
                 objects.NetworkRequest(port_id=uuids.portid_4),
                 objects.NetworkRequest(port_id=uuids.portid_5),
-                objects.NetworkRequest(port_id=uuids.trusted_port)])
+                objects.NetworkRequest(port_id=uuids.trusted_port),
+                objects.NetworkRequest(port_id=uuids.portid_vdpa)])
         pci_requests = objects.InstancePCIRequests(requests=[])
         # _get_port_vnic_info should be called for every NetworkRequest with a
         # port_id attribute (so six times)
@@ -5785,13 +5786,14 @@ def test_create_resource_requests(self, getclient,
             (model.VNIC_TYPE_DIRECT_PHYSICAL, None, 'netN', None, None),
             (model.VNIC_TYPE_DIRECT, True, 'netN',
              mock.sentinel.resource_request2, None),
+            (model.VNIC_TYPE_VDPA, None, 'netN', None, None),
         ]
         # _get_physnet_tunneled_info should be called for every NetworkRequest
         # (so seven times)
         mock_get_physnet_tunneled_info.side_effect = [
             ('physnet1', False), ('physnet1', False), ('', True),
             ('physnet1', False), ('physnet2', False), ('physnet3', False),
-            ('physnet4', False),
+            ('physnet4', False), ('physnet1', False)
         ]
         api = neutronapi.API()
 
@@ -5808,12 +5810,13 @@ def test_create_resource_requests(self, getclient,
                 mock.sentinel.request_group1,
                 mock.sentinel.request_group2],
             port_resource_requests)
-        self.assertEqual(5, len(pci_requests.requests))
+        self.assertEqual(6, len(pci_requests.requests))
         has_pci_request_id = [net.pci_request_id is not None for net in
                               requested_networks.objects]
         self.assertEqual(pci_requests.requests[3].spec[0]["dev_type"],
                          "type-PF")
-        expected_results = [True, False, False, True, True, True, True]
+        self.assertEqual(pci_requests.requests[5].spec[0]["dev_type"], "vdpa")
+        expected_results = [True, False, False, True, True, True, True, True]
         self.assertEqual(expected_results, has_pci_request_id)
         # Make sure only the trusted VF has the 'trusted' tag set in the spec.
         for pci_req in pci_requests.requests:
@@ -5827,7 +5830,7 @@ def test_create_resource_requests(self, getclient,
 
         # Only the port with a resource_request will have pci_req.requester_id.
         self.assertEqual(
-            [None, None, None, None, uuids.trusted_port],
+            [None, None, None, None, uuids.trusted_port, None],
             [pci_req.requester_id for pci_req in pci_requests.requests])
 
         self.assertCountEqual(