[PATCH 14/17] driver core: Add a global initial device trust policy

[Leon Romanovsky <leon@kernel.org>]

From: Leon Romanovsky <leonro@nvidia.com>

Confidential guests may require fresh userspace attestation before
permitting any functional driver to probe. Listing individual devices on
the command line leaves unlisted hardware free to probe, and initrd policy
writes arrive too late for built-in drivers.

A system-wide initial policy is needed to keep unlisted devices waiting
for authorization while allowing explicit exceptions for devices needed
to reach the initrd. Existing boot behavior must remain available when
no global policy is selected.

Signed-off-by: Leon Romanovsky <leonro@nvidia.com>
---
 Documentation/ABI/testing/sysfs-devices-trust   |  7 +++--
 Documentation/admin-guide/kernel-parameters.txt | 23 ++++++++++++--
 drivers/base/base.h                             |  3 ++
 drivers/base/trust.c                            | 41 ++++++++++++++++++++-----
 4 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/Documentation/ABI/testing/sysfs-devices-trust b/Documentation/ABI/testing/sysfs-devices-trust
index c0ce905b625d0..6f52102a1dfbf 100644
--- a/Documentation/ABI/testing/sysfs-devices-trust
+++ b/Documentation/ABI/testing/sysfs-devices-trust
@@ -17,8 +17,11 @@ 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.
+		A non-default device_trust.default= kernel command-line value
+		replaces the bus policy before registration. A matching
+		device_trust= entry takes precedence over both, regardless
+		of command-line order. Boot policy also applies to new devices
+		discovered after boot.
 		Otherwise, device_trust.driver= can initialize policy on the
 		first binding attempt with a matching driver rule. A successful
 		policy write, including the existing value, suppresses this
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index b1d6999a5befa..458f59a8af854 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -1267,9 +1267,8 @@ Kernel parameters
 			/sys/bus/<bus>/devices/<device>. The first colon separates
 			the bus name; further colons belong to the device name.
 			Policies are default, disabled, adversary, and full.
-			Entries override bus-initialized requested policy;
-			unlisted devices retain their existing policy.
-			Per-device entries take precedence over device_trust.driver.
+			Entries override device_trust.default, device_trust.driver,
+			and bus-initialized policy, regardless of option order.
 			The last entry for a device wins. If specified more than
 			once, the last valid list replaces all earlier lists.
 			Malformed lists are warned about and ignored in full.
@@ -1285,6 +1284,24 @@ Kernel parameters
 			device_trust=pci:0000:01:00.0=adversary,pci:0000:02:00.0=disabled
 			See Documentation/driver-api/driver-model/device-trust.rst.
 
+	device_trust.default=
+			[KNL] Set initial trust policy for devices without a
+			matching device_trust= entry, including hotplugged devices.
+			A matching device_trust.driver= rule can replace this
+			initial policy at the first binding attempt.
+			Format: { default | disabled | adversary | full }
+			default preserves bus-initialized policy (the default).
+			Other values override bus-initialized policy before
+			probing, including for built-in drivers.
+			The last valid value wins; invalid values are warned
+			about and ignored.
+			Without a matching driver rule, disabled prevents binding
+			until userspace authorizes each device by writing adversary
+			or full to trust_policy. Boot-critical devices need explicit
+			device or driver rules to operate before userspace. DMA
+			containment remains a bus and IOMMU responsibility.
+			See Documentation/driver-api/driver-model/device-trust.rst.
+
 	device_trust.driver=
 			[KNL] Set initial device trust policy by driver name,
 			including for drivers built into the kernel.
diff --git a/drivers/base/base.h b/drivers/base/base.h
index dd78857abf74f..5ff3217eb916e 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -193,6 +193,9 @@ bool device_trust_claim_allowed(const struct device *dev,
 				const struct device_driver *drv,
 				const char *device_options,
 				const char *driver_options);
+void device_trust_apply_boot_policy(struct device *dev,
+				    enum device_trust_policy policy,
+				    const char *options);
 #endif
 
 /* All active trust level transitions are serialized by the device lock. */
diff --git a/drivers/base/trust.c b/drivers/base/trust.c
index 4bcda888591a5..c2463b51c3a03 100644
--- a/drivers/base/trust.c
+++ b/drivers/base/trust.c
@@ -249,6 +249,7 @@ const struct attribute_group device_trust_attr_group = {
 
 static const char *device_trust_cmdline __ro_after_init;
 static const char *device_trust_driver_cmdline __ro_after_init;
+static enum device_trust_policy device_trust_default_policy __ro_after_init;
 
 static int device_trust_parse_policy(const char *options, const char *target_bus,
 				     const char *target_name,
@@ -410,18 +411,44 @@ static int __init device_trust_driver_setup(char *str)
 }
 __setup("device_trust.driver=", device_trust_driver_setup);
 
+static int __init device_trust_default_setup(char *str)
+{
+	int policy = match_string(device_trust_policy_names,
+				  ARRAY_SIZE(device_trust_policy_names), str);
+
+	if (policy < 0) {
+		pr_warn("device_trust: ignoring invalid default policy '%s'\n", str);
+		return 1;
+	}
+
+	device_trust_default_policy = policy;
+	return 1;
+}
+__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 (dev->p && dev->p->trust_initialized)
+		return;
+
+	if (policy != DEVICE_TRUST_POLICY_DEFAULT)
+		dev->trust_policy = policy;
+	if (options &&
+	    device_trust_parse_cmdline(options, dev, &dev->trust_policy) > 0 &&
+	    dev->p)
+		dev->p->trust_policy_override = true;
+}
+EXPORT_SYMBOL_IF_KUNIT(device_trust_apply_boot_policy);
+
 /**
  * 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 (dev->p && dev->p->trust_initialized)
-		return;
-
-	if (device_trust_cmdline &&
-	    device_trust_parse_cmdline(device_trust_cmdline, dev,
-				       &dev->trust_policy) > 0 && dev->p)
-		dev->p->trust_policy_override = true;
+	device_trust_apply_boot_policy(dev, device_trust_default_policy,
+				       device_trust_cmdline);
 }
 EXPORT_SYMBOL_GPL(device_trust_init);

-- 
2.56.0