From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1795030137; b=e+mELxumYAftt61/FoSui1TR6pRz0Yncwrmhq/f9lCmjIf5GdHnYpctge+IcWdZVTGaB pJmD/t7VlMa3eS/gSAsEvfu0NircON+Raircv6duPmzWq51fzgkY6eScsQFwmd/0B/74x KBt/l/0edoxYfRkLQZY3Gnu475cjsJNsKEqXUu85FTROjGh6cGcCStSOHdSQkQevFxpe/ KwGvBZuCbRSMCGQuPgGcIy4ZbEBRjXKzxWwHmAMQkHfUVdhvUHy2VXoxwfQtsbuk7hCwD EJ8pgTPdU0I/34vlvfbV8xAzI7yAUC0QCE521kgTDXy7wo+xnQInEKKJ2KLki+lvQ2g== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795030137; h=Received:DKIM-Signature:From:To:Cc:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:Content-Type:X-Mailer: Content-Transfer-Encoding; bh=Rlv7G/yUKVfYw6iAE/5d/wsSH8Rm3THo9SyefxpnwoU=; b=kERi/NVPc82D9BC8U9bbupporryTGBsM4TZo00GDSzn17/HAy/Kmy+3bzwAhWkMGNc3R bFLH3O46PtesvKkIaIXslZtz9E0yfWqY4bXkNPmqCPwsWZgcmQeF8MztJHCvNLzb7d6D0 xATxndO07HaSccnWGcyxjo8pOsYDCAsrCuq0zPIXhtZXmJ73+vW2zhuE6gcaANYqu1eWk 6LV65DqsLT0Gd6FFz6oTBbk3y3nYwLWR0GPbiH1Kz69H9BhXY5k5i5Yey0cZEeQRAJY4D uwg6vFwuGgiiK+laDQ5s/HZAxUDQ2Ee8d2Sp0MXhZCzVw/lkDxoFu+lVFU9eYODRMDA== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=ZH49OPcd; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 60BAD6076088; Wed, 18 Nov 2026 19:28:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=ZH49OPcd Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5B24F1F000C4; Wed, 18 Nov 2026 19:28:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795030137; bh=Rlv7G/yUKVfYw6iAE/5d/wsSH8Rm3THo9SyefxpnwoU=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=ZH49OPcd6GPiyPvVs2rjoeRv3Nr/rQ+3eXz5+l1laWgJEhMXpM/njgKCvjiEHZn3j l39Ia4W+qEYLT6By01Y0O2K1GSxUgVEYwK5FwPV2AC2Cx4wWTeGdDJp0QmUyIebH7u DirXLygFbSVlJxMLUCVIwLkdLgui4ENbcVN8im8VCKGC6kmQ0lWl0qBLMmVO0/LF6a GFW//pnaGCsIE2M9i/W7a79LkImSFwcgAfo+74T2LlDRJPeNXeahM9WxL+dZ+00iyE WvtKSd+lkxkijanKzElRwboDzXRm7h+XdCwqRtfH/ygIhVrLcmFVFPbhga1WZCbYlB cElroNiRdC5cQ== From: Leon Romanovsky To: Greg Kroah-Hartman , "Rafael J. Wysocki" , Danilo Krummrich , Dmitry Torokhov , Andrew Lunn , Heiner Kallweit , Russell King , "David S. Miller" , Jakub Kicinski , Paolo Abeni , Johannes Berg , Jonathan Corbet , Shuah Khan , Randy Dunlap , Bjorn Helgaas , "Joerg Roedel (AMD)" , Suravee Suthikulpanit , Vasant Hegde , Will Deacon , Robin Murphy , David Woodhouse , Lu Baolu , Johan Hovold , Eric Dumazet , Marcel Holtmann , Luiz Augusto von Dentz , Nipun Gupta , Nikhil Agarwal , Pieter Jansen van Vuuren , Chris Lu , Mans Rullgard , Alan Stern , Jaroslav Kysela , Takashi Iwai , Andrew Morton , Cornelia Huck , Andrew Morton , Jeff Garzik Cc: linux-kernel@vger.kernel.org, driver-core@lists.linux.dev, linux-input@vger.kernel.org, netdev@vger.kernel.org, linux-wireless@vger.kernel.org, linux-usb@vger.kernel.org, linux-bluetooth@vger.kernel.org, linux-acpi@vger.kernel.org, linux-doc@vger.kernel.org, linux-pci@vger.kernel.org, iommu@lists.linux.dev, linux-coco@lists.linux.dev, Alexey Kardashevskiy , Luiz Augusto von Dentz , Greg Kroah-Hartman , linux-sound@vger.kernel.org, Jason Gunthorpe Subject: [PATCH v3 26/31] PCI: Use device trust for platform restrictions Date: Wed, 18 Nov 2026 21:26:56 +0200 Message-ID: <20261118-device-trust-core-v3-26-d655875c4bfb@nvidia.com> X-Mailer: git-send-email 2.56.1 In-Reply-To: <20261118-device-trust-core-v3-0-d655875c4bfb@nvidia.com> References: <20261118-device-trust-core-v3-0-d655875c4bfb@nvidia.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" X-Mailer: b4 0.15-dev-18f8f Content-Transfer-Encoding: 8bit From: Leon Romanovsky 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 --- .../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