[PATCH v2 13/19] driver core: Accept device trust policy on the kernel command line

From: Leon Romanovsky

Date: Mon Nov 09 2026 - 02:50:36 EST


From: Leon Romanovsky <leonro@xxxxxxxxxx>

Built-in drivers can probe before initrd policy agents start. Fresh
attestation therefore requires disabled policy before those attempts.

Add device_trust=<bus>:<device>=<policy>[,...] to initialize requested
policy before registration. Apply PCI overrides during discovery so IOMMU
and ACS decisions use the same initial policy as binding. Retain rules for
hotplug, preserve admission history when a device object is reused, and
leave unlisted devices unchanged.

Signed-off-by: Leon Romanovsky <leonro@xxxxxxxxxx>
---
Documentation/ABI/testing/sysfs-devices-trust | 2 +
Documentation/admin-guide/kernel-parameters.txt | 9 +++
drivers/base/base.h | 8 +++
drivers/base/trust.c | 93 +++++++++++++++++++++++--
drivers/pci/probe.c | 1 +
5 files changed, 109 insertions(+), 4 deletions(-)

diff --git a/Documentation/ABI/testing/sysfs-devices-trust b/Documentation/ABI/testing/sysfs-devices-trust
index d68113b0d6b08..fd523bbe7bdc6 100644
--- a/Documentation/ABI/testing/sysfs-devices-trust
+++ b/Documentation/ABI/testing/sysfs-devices-trust
@@ -14,6 +14,8 @@ Description:
value may be selected by the bus before the device is
registered; otherwise it is "default". The policy is resolved
to an active trust level before the device is probed.
+ A matching device_trust= kernel command-line entry overrides
+ the initial requested policy before registration.

The values are "default", "disabled", "adversary", and
"full". "default" lets the bus select the active trust level.
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 2d046c79becd9..fbc0cd21bf09f 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -1259,6 +1259,15 @@ Kernel parameters
dell_smm_hwmon.fan_max=
[HW] Maximum configurable fan speed.

+ device_trust= [KNL]
+ Set initial device trust policy before probing, including
+ for devices added after boot.
+ Format: <bus>:<device>=<policy>[,...]
+ Names match exactly as in /sys/bus/<bus>/devices/<device>.
+ Policies are default, disabled, adversary, and full.
+ Entries override bus policy and device_trust.default.
+ See Documentation/driver-api/driver-model/device-trust.rst.
+
device_trust.default=
[KNL] Set the initial trust policy for all devices.
Format: { default | disabled | adversary | full }
diff --git a/drivers/base/base.h b/drivers/base/base.h
index 623444c7a3be8..59da537462a57 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -178,6 +178,14 @@ void device_release_driver_internal(struct device *dev, const struct device_driv

extern const struct attribute_group device_trust_attr_group;

+#if IS_ENABLED(CONFIG_KUNIT)
+int device_trust_parse_cmdline(const char *options, const struct device *dev,
+ enum device_trust_policy *policy);
+void device_trust_apply_boot_policy(struct device *dev,
+ enum device_trust_policy policy,
+ const char *options);
+#endif
+
/* Full-only manual attachment uses the caller's subsystem serialization. */
void device_trust_init_state(struct device *dev);
int device_trust_prepare(struct device *dev, const struct device_driver *drv);
diff --git a/drivers/base/trust.c b/drivers/base/trust.c
index 86ce2751f30a3..f581857642493 100644
--- a/drivers/base/trust.c
+++ b/drivers/base/trust.c
@@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-2.0

+#include <linux/ctype.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/export.h>
@@ -211,6 +212,79 @@ static struct attribute *device_trust_attrs[] = {
const struct attribute_group device_trust_attr_group = {
.attrs = device_trust_attrs,
};
+
+static const char *device_trust_cmdline __ro_after_init;
+
+VISIBLE_IF_KUNIT int device_trust_parse_cmdline(const char *options,
+ const struct device *dev,
+ enum device_trust_policy *policy)
+{
+ enum device_trust_policy selected = DEVICE_TRUST_POLICY_DEFAULT;
+ const char *entry = options;
+ bool matched = false;
+
+ if (!*entry)
+ return -EINVAL;
+
+ for (;;) {
+ const char *end = entry + strcspn(entry, ",");
+ const char *bus_end, *name, *level, *p;
+ unsigned int i;
+
+ bus_end = memchr(entry, ':', end - entry);
+ if (!bus_end || bus_end == entry ||
+ memchr(entry, '=', bus_end - entry))
+ return -EINVAL;
+ name = bus_end + 1;
+ level = memchr(name, '=', end - name);
+ if (!level || level == name || level + 1 == end)
+ return -EINVAL;
+
+ for (p = entry; p < end; p++)
+ if (isspace(*p) || iscntrl(*p) || *p == '"')
+ return -EINVAL;
+
+ for (i = 0; i < ARRAY_SIZE(device_trust_policy_names); i++)
+ if (strlen(device_trust_policy_names[i]) == end - level - 1 &&
+ !strncmp(level + 1, device_trust_policy_names[i],
+ end - level - 1))
+ break;
+ if (i == ARRAY_SIZE(device_trust_policy_names))
+ return -EINVAL;
+
+ if (dev && dev->bus && dev_name(dev) &&
+ strlen(dev->bus->name) == bus_end - entry &&
+ !strncmp(dev->bus->name, entry, bus_end - entry) &&
+ strlen(dev_name(dev)) == level - name &&
+ !strncmp(dev_name(dev), name, level - name)) {
+ selected = i;
+ matched = true;
+ }
+
+ if (!*end)
+ break;
+ entry = end + 1;
+ }
+
+ if (matched)
+ *policy = selected;
+ return matched;
+}
+EXPORT_SYMBOL_IF_KUNIT(device_trust_parse_cmdline);
+
+static int __init device_trust_setup(char *str)
+{
+ if (device_trust_parse_cmdline(str, NULL, NULL) < 0) {
+ pr_warn("device_trust: ignoring invalid policy list '%s'\n", str);
+ return 1;
+ }
+
+ /* The command-line buffer survives init. */
+ device_trust_cmdline = str;
+ return 1;
+}
+__setup("device_trust=", device_trust_setup);
+
static int __init device_trust_default_setup(char *str)
{
int policy = match_string(device_trust_policy_names,
@@ -226,13 +300,24 @@ static int __init device_trust_default_setup(char *str)
}
__setup("device_trust.default=", device_trust_default_setup);

+VISIBLE_IF_KUNIT void device_trust_apply_boot_policy(struct device *dev,
+ enum device_trust_policy policy,
+ const char *options)
+{
+ if (policy != DEVICE_TRUST_POLICY_DEFAULT)
+ dev->trust_policy = policy;
+ if (options)
+ device_trust_parse_cmdline(options, dev, &dev->trust_policy);
+}
+EXPORT_SYMBOL_IF_KUNIT(device_trust_apply_boot_policy);
+
/**
- * device_trust_init - Apply global boot policy before registration
- * @dev: unregistered device with its initial policy set
+ * device_trust_init - Apply boot policy before registration or bus policy use
+ * @dev: unregistered device with its bus, name, and default policy set
*/
void device_trust_init(struct device *dev)
{
- if (device_trust_default_policy != DEVICE_TRUST_POLICY_DEFAULT)
- dev->trust_policy = device_trust_default_policy;
+ device_trust_apply_boot_policy(dev, device_trust_default_policy,
+ device_trust_cmdline);
}
EXPORT_SYMBOL_GPL(device_trust_init);
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 9a178e0e5f7f4..5b6960bbb35bc 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -2083,6 +2083,7 @@ int pci_setup_device(struct pci_dev *dev)
set_pcie_cxl(dev);

set_pcie_untrusted(dev);
+ device_trust_init(&dev->dev);

/* "Unknown power state" */
dev->current_state = PCI_UNKNOWN;

--
2.56.0