From: Leon Romanovsky Built-in drivers can probe before initrd policy agents start. Fresh attestation therefore requires disabled policy before those attempts. Add device_trust=:=[,...] 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 --- 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: :=[,...] + Names match exactly as in /sys/bus//devices/. + 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 #include #include #include @@ -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