mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Alexey Kardashevskiy <aik@ozlabs.ru>
To: Leon Romanovsky <leon@kernel.org>,
	Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
	"Rafael J. Wysocki" <rafael@kernel.org>,
	Danilo Krummrich <dakr@kernel.org>,
	Dmitry Torokhov <dmitry.torokhov@gmail.com>,
	Andrew Lunn <andrew@lunn.ch>,
	Heiner Kallweit <hkallweit1@gmail.com>,
	Russell King <linux@armlinux.org.uk>,
	"David S. Miller" <davem@davemloft.net>,
	Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>,
	Johannes Berg <johannes@sipsolutions.net>,
	Jonathan Corbet <corbet@lwn.net>,
	Shuah Khan <skhan@linuxfoundation.org>,
	Randy Dunlap <rdunlap@infradead.org>,
	Bjorn Helgaas <bhelgaas@google.com>,
	"Joerg Roedel (AMD)" <joro@8bytes.org>,
	Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>,
	Vasant Hegde <vasant.hegde@amd.com>,
	Will Deacon <will@kernel.org>,
	Robin Murphy <robin.murphy@arm.com>,
	David Woodhouse <dwmw2@infradead.org>,
	Lu Baolu <baolu.lu@linux.intel.com>,
	Johan Hovold <johan@kernel.org>,
	Eric Dumazet <edumazet@kernel.org>,
	Marcel Holtmann <marcel@holtmann.org>,
	Luiz Augusto von Dentz <luiz.dentz@gmail.com>,
	Nipun Gupta <nipun.gupta@amd.com>,
	Nikhil Agarwal <nikhil.agarwal@amd.com>,
	Pieter Jansen van Vuuren <pieter.jansen-van-vuuren@amd.com>
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, Jason Gunthorpe <jgg@ziepe.ca>,
	Alexey Kardashevskiy <aik@amd.com>
Subject: Re: [PATCH v2 11/19] driver core: Introduce a generic device trust level
Date: Fri, 13 Nov 2026 22:30:23 +1100	[thread overview]
Message-ID: <de5772b3-c340-4822-a49a-1434ece1b144@ozlabs.ru> (raw)
In-Reply-To: <20261109-device-trust-core-v2-11-3b12d9a9f861@nvidia.com>

On 9/11/26 18:33, Leon Romanovsky wrote:
> From: Leon Romanovsky <leonro@nvidia.com>
> 
> Device setup needs a common operating policy before driver probing or DMA
> configuration. Userspace must be able to hold devices disabled until it
> authorizes them.
> 
> Add generic trust admission with an immutable global boot policy. Restrict
> the compatibility attachment API to explicit global full policy and full
> operation, checking admission before probe. Keep the operating level
> stable until teardown and retain normal locked admission for other callers.
> 
> Signed-off-by: Leon Romanovsky <leonro@nvidia.com>

this got many CCs except the one where I was (eagerly) looking for it: linux-coco@lists.linux.dev :)


> ---
>   Documentation/admin-guide/kernel-parameters.txt |   8 ++
>   drivers/base/Makefile                           |   2 +-
>   drivers/base/base.h                             |  16 +++
>   drivers/base/core.c                             |   3 +
>   drivers/base/dd.c                               |  38 ++++++-
>   drivers/base/trust.c                            | 132 ++++++++++++++++++++++++
>   include/linux/device.h                          |   8 ++
>   include/linux/device/bus.h                      |  10 ++
>   include/linux/device/trust.h                    |  44 ++++++++
>   9 files changed, 258 insertions(+), 3 deletions(-)
> 
> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> index 0b3c140babd94..81a936dca9476 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -1259,6 +1259,14 @@ Kernel parameters
>   	dell_smm_hwmon.fan_max=
>   			[HW] Maximum configurable fan speed.
>   
> +	device_trust.default=
> +			[KNL] Set the initial trust policy for all devices.
> +			Format: { default | disabled | adversary | full }
> +			If omitted or set to default, preserve bus policy.
> +			Other values replace bus policy. The last valid value wins.
> +			Full-only manual driver attachment requires full; other
> +			global policies reject it before the probe callback.
> +
>   	dfltcc=		[HW,S390]
>   			Format: { on | off | def_only | inf_only | always }
>   			on:       s390 zlib hardware support for compression on
> diff --git a/drivers/base/Makefile b/drivers/base/Makefile
> index 435710f643a5c..cb3bd5fa2287a 100644
> --- a/drivers/base/Makefile
> +++ b/drivers/base/Makefile
> @@ -3,7 +3,7 @@
>   
>   obj-y			:= component.o core.o bus.o dd.o syscore.o \
>   			   driver.o class.o platform.o \
> -			   cpu.o firmware.o init.o map.o devres.o \
> +			   cpu.o firmware.o init.o map.o devres.o trust.o \
>   			   attribute_container.o transport_class.o \
>   			   topology.o container.o property.o cacheinfo.o \
>   			   swnode.o faux.o
> diff --git a/drivers/base/base.h b/drivers/base/base.h
> index 866b2beb6baa2..ba8b5b3c51a65 100644
> --- a/drivers/base/base.h
> +++ b/drivers/base/base.h
> @@ -10,6 +10,7 @@
>    * shared outside of the drivers/base/ directory.
>    *
>    */
> +#include <linux/device/trust.h>
>   #include <linux/notifier.h>
>   
>   /**
> @@ -88,6 +89,13 @@ struct driver_private {
>   };
>   #define to_driver(obj) container_of(obj, struct driver_private, kobj)
>   
> +enum device_trust_state {
> +	DEVICE_TRUST_SELECTABLE,
> +	DEVICE_TRUST_WAITING,

What is the exact difference between these? "Waiting" is waiting for what?

> +	DEVICE_TRUST_AUTHORIZED,
> +	DEVICE_TRUST_COMMITTED,

And exact difference between these two? Some documentation would be great.

dev->trust_policy is how we want the device to operate.
dev->p->trust_state is where the device is on its way to that final policy.

right?


> +};
> +
>   /**
>    * struct device_private - structure to hold the private to the driver core
>    *			   portions of the device structure.
> @@ -105,6 +113,7 @@ struct driver_private {
>    *			   dev_err_probe() for later retrieval via debugfs
>    * @device: pointer back to the struct device that this structure is
>    *	    associated with.
> + * @trust_state: policy admission state
>    * @dead: This device is currently either in the process of or has been
>    *	  removed from the system. Any asynchronous events scheduled for this
>    *	  device should exit without taking any action.
> @@ -121,6 +130,7 @@ struct device_private {
>   	const struct device_driver *async_driver;
>   	char *deferred_probe_reason;
>   	struct device *device;
> +	enum device_trust_state trust_state;
>   	u8 dead:1;
>   };
>   #define to_device_private_parent(obj)	\
> @@ -166,6 +176,12 @@ void bus_remove_driver(struct device_driver *drv);
>   void device_release_driver_internal(struct device *dev, const struct device_driver *drv,
>   				    struct device *parent);
>   
> +/* 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);
> +int device_trust_prepare_full(struct device *dev, const struct device_driver *drv);
> +void device_trust_clear(struct device *dev);
> +
>   void driver_detach(const struct device_driver *drv);
>   void driver_deferred_probe_del(struct device *dev);
>   void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf);
> diff --git a/drivers/base/core.c b/drivers/base/core.c
> index cbe05197d4a0b..6b94a163cda8d 100644
> --- a/drivers/base/core.c
> +++ b/drivers/base/core.c
> @@ -3681,6 +3681,9 @@ int device_add(struct device *dev)
>   	if (error)
>   		goto name_error;
>   
> +	device_trust_init(dev);
> +	device_trust_init_state(dev);
> +
>   	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
>   
>   	parent = get_device(dev->parent);
> diff --git a/drivers/base/dd.c b/drivers/base/dd.c
> index 0f56c3d825731..449986f741009 100644
> --- a/drivers/base/dd.c
> +++ b/drivers/base/dd.c
> @@ -558,12 +558,24 @@ static int __device_bind_driver(struct device *dev)
>    */
>   int device_bind_driver(struct device *dev)
>   {
> -	return __device_bind_driver(dev);
> +	int ret;
> +
> +	if (dev->bus && dev->bus->trust_resolve)
> +		return -EOPNOTSUPP;
> +
> +	ret = device_trust_prepare(dev, dev->driver);
> +	if (ret)
> +		return ret;
> +
> +	ret = __device_bind_driver(dev);
> +	if (ret)
> +		device_trust_clear(dev);
> +	return ret;
>   }
>   EXPORT_SYMBOL_GPL(device_bind_driver);
>   
>   /**
> - * device_driver_attach_full - attach a driver using subsystem serialization
> + * device_driver_attach_full - attach a driver under the global full policy
>    * @drv: driver to attach
>    * @dev: device to attach it to
>    *
> @@ -576,6 +588,12 @@ EXPORT_SYMBOL_GPL(device_bind_driver);
>    * It calls the bus or driver probe callback and publishes the binding without
>    * performing the normal driver-core DMA, pinctrl or power-domain setup.
>    *
> + * Requires device_trust.default=full and a full operating level. Runtime
> + * policy writes are disabled in this mode; boot policy exceptions still
> + * apply. When driver boot rules exist, an explicit device boot rule must
> + * exclude them for @dev. Buses with a trust resolver must use
> + * device_driver_attach().
> + *
>    * Return: 0 on success, or a negative error before binding.
>    */
>   int device_driver_attach_full(const struct device_driver *drv, struct device *dev)
> @@ -587,6 +605,10 @@ int device_driver_attach_full(const struct device_driver *drv, struct device *de
>   	if (dev->driver)
>   		return -EBUSY;
>   
> +	ret = device_trust_prepare_full(dev, drv);
> +	if (ret)
> +		return ret;
> +
>   	device_set_driver(dev, drv);
>   	if (dev->bus->probe)
>   		ret = dev->bus->probe(dev);
> @@ -610,6 +632,7 @@ int device_driver_attach_full(const struct device_driver *drv, struct device *de
>   	devres_release_all(dev);
>   	device_set_driver(dev, NULL);
>   	dev_set_drvdata(dev, NULL);
> +	WRITE_ONCE(dev->trust_level, DEVICE_TRUST_DISABLED);
>   	if (ret == -EPROBE_DEFER)
>   		return -EAGAIN;
>   	return ret;
> @@ -739,6 +762,14 @@ static int really_probe(struct device *dev, const struct device_driver *drv)
>   	}
>   
>   re_probe:
> +	ret = device_trust_prepare(dev, drv);
> +	if (ret) {
> +		device_links_no_driver(dev);
> +		/* Report it like a probe error so a scan tries the next driver. */
> +		ret = -ret;
> +		goto done;
> +	}
> +
>   	device_set_driver(dev, drv);
>   
>   	/* If using pinctrl, bind pins now before probing */
> @@ -805,6 +836,7 @@ static int really_probe(struct device *dev, const struct device_driver *drv)
>   		if (dev->bus && dev->bus->dma_cleanup)
>   			dev->bus->dma_cleanup(dev);
>   		device_unbind_cleanup(dev);
> +		device_trust_clear(dev);
>   
>   		goto re_probe;
>   	}
> @@ -831,6 +863,7 @@ static int really_probe(struct device *dev, const struct device_driver *drv)
>   pinctrl_bind_failed:
>   	device_links_no_driver(dev);
>   	device_unbind_cleanup(dev);
> +	device_trust_clear(dev);
>   done:
>   	return ret;
>   }
> @@ -1420,6 +1453,7 @@ static void __device_release_driver(struct device *dev, struct device *parent)
>   			dev->bus->dma_cleanup(dev);
>   
>   		device_unbind_cleanup(dev);
> +		device_trust_clear(dev);
>   		device_links_driver_cleanup(dev);
>   
>   		klist_remove(&dev->p->knode_driver);
> diff --git a/drivers/base/trust.c b/drivers/base/trust.c
> new file mode 100644
> index 0000000000000..6a71abf10b3bb
> --- /dev/null
> +++ b/drivers/base/trust.c
> @@ -0,0 +1,132 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/device.h>
> +#include <linux/errno.h>
> +#include <linux/export.h>
> +#include <linux/init.h>
> +#include <linux/string.h>
> +#include <kunit/visibility.h>
> +
> +#include "base.h"
> +
> +static enum device_trust_policy device_trust_default_policy __ro_after_init;
> +
> +void device_trust_init_state(struct device *dev)
> +{
> +	dev->p->trust_state = dev->trust_policy == DEVICE_TRUST_POLICY_DISABLED ?
> +		DEVICE_TRUST_WAITING : DEVICE_TRUST_SELECTABLE;
> +}
> +
> +static int __device_trust_prepare(struct device *dev,
> +				  const struct device_driver *drv, bool full_only)
> +{
> +	enum device_trust_policy policy;
> +	enum device_trust_level level;
> +	int ret;
> +
> +	policy = dev->trust_policy;
> +
> +	if (policy == DEVICE_TRUST_POLICY_DISABLED)
> +		return -EPERM;
> +	if (dev->bus && dev->bus->trust_resolve) {
> +		ret = dev->bus->trust_resolve(dev, drv, policy, &level);
> +		if (ret)
> +			return ret;
> +	} else {
> +		level = policy == DEVICE_TRUST_POLICY_ADVERSARY ?
> +			DEVICE_TRUST_ADVERSARY : DEVICE_TRUST_FULL;
> +	}
> +	if (level == DEVICE_TRUST_DISABLED)
> +		return -EPERM;

This check can go right after trust_resolve() above. Thanks,


> +	if (full_only && level != DEVICE_TRUST_FULL)
> +		return -EPERM;
> +	if (dev->p->trust_state == DEVICE_TRUST_COMMITTED &&
> +	    dev->trust_committed_level != level)
> +		return -EINVAL;
> +
> +	WRITE_ONCE(dev->trust_committed_level, level);
> +	dev->p->trust_state = DEVICE_TRUST_COMMITTED;
> +	WRITE_ONCE(dev->trust_level, level);
> +	return 0;
> +}
> +
> +int device_trust_prepare(struct device *dev, const struct device_driver *drv)
> +{
> +	device_lock_assert(dev);
> +	return __device_trust_prepare(dev, drv, false);
> +}
> +
> +int device_trust_prepare_full(struct device *dev, const struct device_driver *drv)
> +{
> +	if (device_trust_default_policy != DEVICE_TRUST_POLICY_FULL)
> +		return -EPERM;
> +
> +	return __device_trust_prepare(dev, drv, true);
> +}
> +
> +void device_trust_clear(struct device *dev)
> +{
> +	device_lock_assert(dev);
> +	WRITE_ONCE(dev->trust_level, DEVICE_TRUST_DISABLED);
> +}
> +
> +/**
> + * device_get_trust_level - Return a device's active trust level
> + * @dev: device to inspect
> + *
> + * The value is stable from the start of DMA configuration through the end of
> + * DMA cleanup. An unbound device has %DEVICE_TRUST_DISABLED as its active
> + * trust level.
> + *
> + * Return: The active trust level for the current bind transaction.
> + */
> +enum device_trust_level device_get_trust_level(const struct device *dev)
> +{
> +	return READ_ONCE(dev->trust_level);
> +}
> +EXPORT_SYMBOL_GPL(device_get_trust_level);
> +
> +/**
> + * device_is_adversarial - Test whether a device is operated as an adversary
> + * @dev: device to inspect
> + *
> + * Return: True when the active trust level is %DEVICE_TRUST_ADVERSARY.
> + */
> +bool device_is_adversarial(const struct device *dev)
> +{
> +	return device_get_trust_level(dev) == DEVICE_TRUST_ADVERSARY;
> +}
> +EXPORT_SYMBOL_GPL(device_is_adversarial);
> +
> +static const char * const device_trust_policy_names[] = {
> +	[DEVICE_TRUST_POLICY_DEFAULT] = "default",
> +	[DEVICE_TRUST_POLICY_DISABLED] = "disabled",
> +	[DEVICE_TRUST_POLICY_ADVERSARY] = "adversary",
> +	[DEVICE_TRUST_POLICY_FULL] = "full",
> +};
> +
> +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);
> +
> +/**
> + * device_trust_init - Apply global boot policy before registration
> + * @dev: unregistered device with its initial 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;
> +}
> +EXPORT_SYMBOL_GPL(device_trust_init);
> diff --git a/include/linux/device.h b/include/linux/device.h
> index 42e966ebaa2d3..57d2e1b0d98ad 100644
> --- a/include/linux/device.h
> +++ b/include/linux/device.h
> @@ -30,6 +30,7 @@
>   #include <linux/device/class.h>
>   #include <linux/device/devres.h>
>   #include <linux/device/driver.h>
> +#include <linux/device/trust.h>
>   #include <linux/cleanup.h>
>   #include <asm/device.h>
>   
> @@ -695,6 +696,10 @@ enum struct_device_flags {
>    * @removable:  Whether the device can be removed from the system. This
>    *              should be set by the subsystem / bus driver that discovered
>    *              the device.
> + * @trust_policy: Requested operating policy, resolved before driver probe.
> + * @trust_level: Active trust level while a driver is bound, see
> + *		device_get_trust_level().
> + * @trust_committed_level: Operating level retained across bind transactions.
>    * @flags:	DEV_FLAG_XXX flags. Use atomic bitfield operations to modify.
>    *
>    * At the lowest level, every device in a Linux system is represented by an
> @@ -798,6 +803,9 @@ struct device {
>   	struct device_physical_location *physical_location;
>   
>   	enum device_removable	removable;
> +	enum device_trust_policy trust_policy;
> +	enum device_trust_level trust_level;
> +	enum device_trust_level trust_committed_level;
>   
>   	DECLARE_BITMAP(flags, DEV_FLAG_COUNT);
>   };
> diff --git a/include/linux/device/bus.h b/include/linux/device/bus.h
> index 9ef7538a9a7f2..ba2b5743a47cd 100644
> --- a/include/linux/device/bus.h
> +++ b/include/linux/device/bus.h
> @@ -17,6 +17,7 @@
>   #include <linux/kobject.h>
>   #include <linux/klist.h>
>   #include <linux/pm.h>
> +#include <linux/device/trust.h>
>   
>   struct device_driver;
>   struct fwnode_handle;
> @@ -59,6 +60,11 @@ struct fwnode_handle;
>    * @resume:	Called to bring a device on this bus out of sleep mode.
>    * @num_vf:	Called to find out how many virtual functions a device on this
>    *		bus supports.
> + * @trust_resolve: Resolve a requested trust policy to an active trust level
> + *		immediately before driver probe. The device lock is held and
> + *		@drv is the candidate driver, which dev->driver does not name
> + *		yet. Return 0 on success or a negative errno. This callback
> + *		must not enable the device.
>    * @dma_configure:	Called to setup DMA configuration on a device on
>    *			this bus.
>    * @dma_cleanup:	Called to cleanup DMA configuration on a device on
> @@ -102,6 +108,10 @@ struct bus_type {
>   
>   	int (*num_vf)(struct device *dev);
>   
> +	int (*trust_resolve)(struct device *dev,
> +			     const struct device_driver *drv,
> +			     enum device_trust_policy policy,
> +			     enum device_trust_level *level);
>   	int (*dma_configure)(struct device *dev);
>   	void (*dma_cleanup)(struct device *dev);
>   
> diff --git a/include/linux/device/trust.h b/include/linux/device/trust.h
> new file mode 100644
> index 0000000000000..b8f5514cacec3
> --- /dev/null
> +++ b/include/linux/device/trust.h
> @@ -0,0 +1,44 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +#ifndef _DEVICE_TRUST_H_
> +#define _DEVICE_TRUST_H_
> +
> +#include <linux/types.h>
> +
> +struct device;
> +
> +/**
> + * enum device_trust_level - active trust level for a device
> + * @DEVICE_TRUST_DISABLED: The device cannot be operated by a driver
> + * @DEVICE_TRUST_ADVERSARY: Operate the device with adversarial restrictions
> + * @DEVICE_TRUST_FULL: Operate the device with the usual kernel privileges
> + *
> + * Active trust levels are discrete states, not an ordered privilege scale.
> + */
> +enum device_trust_level {
> +	DEVICE_TRUST_DISABLED,
> +	DEVICE_TRUST_ADVERSARY,
> +	DEVICE_TRUST_FULL,
> +};
> +
> +/**
> + * enum device_trust_policy - requested device trust policy
> + * @DEVICE_TRUST_POLICY_DEFAULT: Let the bus select the active trust level
> + * @DEVICE_TRUST_POLICY_DISABLED: Request that the device remain disabled
> + * @DEVICE_TRUST_POLICY_ADVERSARY: Request adversarial operation
> + * @DEVICE_TRUST_POLICY_FULL: Request normal operation
> + *
> + * A requested policy is resolved to an active trust level before a driver is
> + * probed.
> + */
> +enum device_trust_policy {
> +	DEVICE_TRUST_POLICY_DEFAULT,
> +	DEVICE_TRUST_POLICY_DISABLED,
> +	DEVICE_TRUST_POLICY_ADVERSARY,
> +	DEVICE_TRUST_POLICY_FULL,
> +};
> +
> +void device_trust_init(struct device *dev);
> +enum device_trust_level device_get_trust_level(const struct device *dev);
> +bool device_is_adversarial(const struct device *dev);
> +
> +#endif /* _DEVICE_TRUST_H_ */
> 


  reply	other threads:[~2026-11-13 11:30 UTC|newest]

Thread overview: 31+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-09  7:33 [PATCH v2 00/19] driver core: Authorize device trust before driver binding Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 01/19] Input: gameport - attach manual drivers through the driver core Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 02/19] wifi: mac80211_hwsim: lock device for manual driver binding Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 03/19] USB: Lock registered interfaces during " Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 04/19] USB: Release interface claims refused during registration Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 05/19] PNP: Attach card devices through the driver core Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 06/19] cdx: Propagate DMA configuration errors Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 07/19] driver core: Report deferred probes through sysfs drivers_probe Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 08/19] driver core: Add a compatibility API for manual driver attachment Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 09/19] Input: serio - use the compatibility driver attachment API Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 10/19] net: phy: Use " Leon Romanovsky
2026-11-09 13:45   ` Andrew Lunn
2026-11-10  7:39     ` Leon Romanovsky
2026-11-10 14:31       ` Andrew Lunn
2026-11-10 14:58         ` Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 11/19] driver core: Introduce a generic device trust level Leon Romanovsky
2026-11-13 11:30   ` Alexey Kardashevskiy [this message]
2026-11-16 12:11     ` Leon Romanovsky
2026-11-16 12:27     ` Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 12/19] driver core: Expose device trust authorization interfaces Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 13/19] driver core: Accept device trust policy on the kernel command line Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 14/19] driver core: Accept device trust policy by driver name Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 15/19] driver core: Expose committed device trust level Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 16/19] driver core: Cover trust authorization and binding with KUnit Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 17/19] driver core: Document trust admission and initrd authorization Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 18/19] PCI: Replace untrusted state with device trust Leon Romanovsky
2026-11-09 13:53   ` Robin Murphy
2026-11-10 12:22     ` Leon Romanovsky
2026-11-10 14:25       ` Jason Gunthorpe
2026-11-10 14:34         ` Leon Romanovsky
2026-11-09  7:33 ` [PATCH v2 19/19] USB: Authorize devices and interfaces through " Leon Romanovsky

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=de5772b3-c340-4822-a49a-1434ece1b144@ozlabs.ru \
    --to=aik@ozlabs.ru \
    --cc=aik@amd.com \
    --cc=andrew@lunn.ch \
    --cc=baolu.lu@linux.intel.com \
    --cc=bhelgaas@google.com \
    --cc=corbet@lwn.net \
    --cc=dakr@kernel.org \
    --cc=davem@davemloft.net \
    --cc=dmitry.torokhov@gmail.com \
    --cc=driver-core@lists.linux.dev \
    --cc=dwmw2@infradead.org \
    --cc=edumazet@kernel.org \
    --cc=gregkh@linuxfoundation.org \
    --cc=hkallweit1@gmail.com \
    --cc=iommu@lists.linux.dev \
    --cc=jgg@ziepe.ca \
    --cc=johan@kernel.org \
    --cc=johannes@sipsolutions.net \
    --cc=joro@8bytes.org \
    --cc=kuba@kernel.org \
    --cc=leon@kernel.org \
    --cc=linux-acpi@vger.kernel.org \
    --cc=linux-bluetooth@vger.kernel.org \
    --cc=linux-doc@vger.kernel.org \
    --cc=linux-input@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-pci@vger.kernel.org \
    --cc=linux-usb@vger.kernel.org \
    --cc=linux-wireless@vger.kernel.org \
    --cc=linux@armlinux.org.uk \
    --cc=luiz.dentz@gmail.com \
    --cc=marcel@holtmann.org \
    --cc=netdev@vger.kernel.org \
    --cc=nikhil.agarwal@amd.com \
    --cc=nipun.gupta@amd.com \
    --cc=pabeni@redhat.com \
    --cc=pieter.jansen-van-vuuren@amd.com \
    --cc=rafael@kernel.org \
    --cc=rdunlap@infradead.org \
    --cc=robin.murphy@arm.com \
    --cc=skhan@linuxfoundation.org \
    --cc=suravee.suthikulpanit@amd.com \
    --cc=vasant.hegde@amd.com \
    --cc=will@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®