[PATCH v3 26/31] PCI: Use device trust for platform restrictions
From: Leon Romanovsky
Date: Wed Nov 18 2026 - 14:37:48 EST
From: Leon Romanovsky <leonro@xxxxxxxxxx>
PCI topology already identifies devices that need restricted operation.
Generic trust policy must inherit that classification so authorization
and PCI restrictions use the same policy.
Resolve discovery-time restrictions from the requested policy, since active
trust is established only before driver setup. Retain the untrusted flag
for IOMMU consumers until their conversion. The initial target is
confidential computing guests without an IOMMU; synchronizing later
authorization with IOMMU domains and ATS remains follow-up work.
Signed-off-by: Leon Romanovsky <leonro@xxxxxxxxxx>
---
.../driver-api/driver-model/device-trust.rst | 10 +++++-----
drivers/pci/ats.c | 4 ++--
drivers/pci/pci.c | 5 +++--
drivers/pci/probe.c | 19 +++++++++----------
drivers/pci/quirks.c | 7 ++++---
include/linux/device.h | 5 +++++
include/linux/pci.h | 10 ++++++++++
7 files changed, 38 insertions(+), 22 deletions(-)
diff --git a/Documentation/driver-api/driver-model/device-trust.rst b/Documentation/driver-api/driver-model/device-trust.rst
index 5c06f3a3340c2..1a1847e943675 100644
--- a/Documentation/driver-api/driver-model/device-trust.rst
+++ b/Documentation/driver-api/driver-model/device-trust.rst
@@ -246,11 +246,11 @@ Adversary does not require an IOMMU. Without an IOMMU group, or with IOMMU
support compiled out, binding uses the platform's normal DMA configuration.
Adversary policy alone does not provide DMA isolation.
-Device trust admission does not change DMA handling, IOMMU domain selection,
-or ATS permission according to active trust. Those remain governed by existing
-bus and platform mechanisms. Integrating them with admission is separate
-work. A setup failure after commitment leaves the chosen mode fixed; it
-cannot fall back to unrestricted.
+The initial target is confidential computing guests without an IOMMU.
+On systems with an IOMMU, policy changes after discovery are not yet
+synchronized with domain selection or ATS configuration. That integration
+is follow-up work. A setup failure after commitment leaves the chosen mode
+fixed; it cannot fall back to unrestricted.
Drivers that manage DMA themselves must provide their own containment.
Drivers that do not use DMA need no domain.
diff --git a/drivers/pci/ats.c b/drivers/pci/ats.c
index 9cb23780093dd..c8c96acc26343 100644
--- a/drivers/pci/ats.c
+++ b/drivers/pci/ats.c
@@ -21,7 +21,7 @@ void pci_ats_init(struct pci_dev *dev)
{
int pos;
- if (pci_ats_disabled())
+ if (pci_ats_disabled() || pci_dev_default_is_restricted(dev))
return;
pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ATS);
@@ -40,7 +40,7 @@ void pci_ats_init(struct pci_dev *dev)
*/
bool pci_ats_supported(struct pci_dev *dev)
{
- if (!dev->ats_cap || dev->untrusted)
+ if (!dev->ats_cap)
return false;
if (dev->is_virtfn)
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 7c6f2aba81443..a60701bdece4c 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1016,8 +1016,9 @@ static void pci_std_enable_acs(struct pci_dev *dev, struct pci_acs *caps)
/* Upstream Forwarding */
caps->ctrl |= (dev->acs_capabilities & PCI_ACS_UF);
- /* Enable Translation Blocking for external devices and noats */
- if (pci_ats_disabled() || dev->external_facing || dev->untrusted)
+ /* Enable Translation Blocking when ATS is unavailable or restricted. */
+ if (pci_ats_disabled() || dev->external_facing ||
+ pci_dev_default_is_restricted(dev))
caps->ctrl |= (dev->acs_capabilities & PCI_ACS_TB);
}
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 9a178e0e5f7f4..9aa69d19ceab4 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -1738,24 +1738,21 @@ static void set_pcie_cxl(struct pci_dev *dev)
}
-static void set_pcie_untrusted(struct pci_dev *dev)
+static void pci_set_default_trust_policy(struct pci_dev *dev)
{
struct pci_dev *parent = pci_upstream_bridge(dev);
if (!parent)
return;
- /*
- * If the upstream bridge is untrusted we treat this device as
- * untrusted as well.
- */
- if (parent->untrusted) {
- dev->untrusted = true;
+
+ if (device_policy_is_adversarial(&parent->dev)) {
+ dev->dev.trust_policy = DEVICE_TRUST_POLICY_ADVERSARY;
return;
}
if (arch_pci_dev_is_removable(dev)) {
- pci_dbg(dev, "marking as untrusted\n");
- dev->untrusted = true;
+ pci_dbg(dev, "setting adversarial trust policy\n");
+ dev->dev.trust_policy = DEVICE_TRUST_POLICY_ADVERSARY;
}
}
@@ -2082,7 +2079,9 @@ int pci_setup_device(struct pci_dev *dev)
set_pcie_cxl(dev);
- set_pcie_untrusted(dev);
+ pci_set_default_trust_policy(dev);
+ dev->untrusted = device_policy_is_adversarial(&dev->dev);
+ device_trust_init(&dev->dev);
/* "Unknown power state" */
dev->current_state = PCI_UNKNOWN;
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 7f1f47ea2ee41..1afad28d1b5e0 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -5525,8 +5525,8 @@ static void pci_quirk_enable_intel_rp_mpc_acs(struct pci_dev *dev)
* Currently this quirk does the equivalent of
* PCI_ACS_SV | PCI_ACS_RR | PCI_ACS_CR | PCI_ACS_UF
*
- * TODO: This quirk also needs to do equivalent of PCI_ACS_TB,
- * if dev->external_facing || dev->untrusted
+ * TODO: This quirk also needs to do the equivalent of PCI_ACS_TB when the
+ * device is external-facing or ATS is restricted by trust policy.
*/
static int pci_quirk_enable_intel_pch_acs(struct pci_dev *dev)
{
@@ -5567,7 +5567,8 @@ static int pci_quirk_enable_intel_spt_pch_acs(struct pci_dev *dev)
ctrl |= (cap & PCI_ACS_CR);
ctrl |= (cap & PCI_ACS_UF);
- if (pci_ats_disabled() || dev->external_facing || dev->untrusted)
+ if (pci_ats_disabled() || dev->external_facing ||
+ pci_dev_default_is_restricted(dev))
ctrl |= (cap & PCI_ACS_TB);
pci_write_config_dword(dev, pos + INTEL_SPT_ACS_CTRL, ctrl);
diff --git a/include/linux/device.h b/include/linux/device.h
index 2914b7191d342..3db6657dffe41 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -933,6 +933,11 @@ static inline bool device_iommu_mapped(struct device *dev)
return (dev->iommu_group != NULL);
}
+static inline bool device_policy_is_adversarial(const struct device *dev)
+{
+ return READ_ONCE(dev->trust_policy) == DEVICE_TRUST_POLICY_ADVERSARY;
+}
+
static inline bool device_policy_is_blocked(const struct device *dev)
{
return READ_ONCE(dev->trust_policy) == DEVICE_TRUST_POLICY_BLOCKED;
diff --git a/include/linux/pci.h b/include/linux/pci.h
index aa3765a20a96c..d8edf8403a5ad 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -616,6 +616,16 @@ static inline struct pci_dev *to_pci_dev(const struct device *dev)
{
return container_of(dev, struct pci_dev, dev);
}
+
+static inline bool
+pci_dev_default_is_restricted(const struct pci_dev *pdev)
+{
+ enum device_trust_policy policy = READ_ONCE(pdev->dev.trust_policy);
+
+ return policy == DEVICE_TRUST_POLICY_BLOCKED ||
+ policy == DEVICE_TRUST_POLICY_ADVERSARY;
+}
+
#define for_each_pci_dev(d) while ((d = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
#define for_each_pci_dev_reverse(d) \
while ((d = pci_get_device_reverse(PCI_ANY_ID, PCI_ANY_ID, d)) != NULL)
--
2.56.1