[RFC PATCH v1 07/11] attestation: Add attestation helpers for PCI/TSM integration

["Aneesh Kumar K.V (Arm)" <aneesh.kumar@kernel.org>]

Add helpers that let the following PCI/TSM patch coordinate device state
changes with attestation state.

PCI child-family operations use ctlv_attestation_op_pre() to acquire the
attestation lock before invoking the backend. They need to validate the
requested device generation before changing state and invalidating
previous evidence.

The existing attestation_state_changed() takes the attestation lock itself.
Factor out a locked variant so those operations can report a state
change without acquiring the same mutex again.

Also expose helpers to check for device-generation overflow, read the
current device generation, and acquire the instance mutex for notifications
outside CTLV dispatch.

Cc: Jiri Pirko <jiri@resnulli.us>
Cc: Jonathan Cameron <jic23@kernel.org>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Signed-off-by: Aneesh Kumar K.V (Arm) <aneesh.kumar@kernel.org>
---
 drivers/attestation/core/core.c | 40 +++++++++++++++++++++++++---
 include/linux/attestation.h     | 47 +++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/drivers/attestation/core/core.c b/drivers/attestation/core/core.c
index 914f29693aee..e35c45bc715d 100644
--- a/drivers/attestation/core/core.c
+++ b/drivers/attestation/core/core.c
@@ -430,14 +430,13 @@ void attestation_mr_destroy(struct attestation_mr *mr)
 }
 EXPORT_SYMBOL_NS_GPL(attestation_mr_destroy, "ATTESTATION");
 
-void attestation_state_changed(struct attestation *att)
+void attestation_state_changed_locked(struct attestation *att)
 {
 	struct attestation_event_batch events = {};
 	bool evidence;
 	int ret;
 
-	guard(mutex)
-		(&att->lock);
+	lockdep_assert_held(&att->lock);
 	if (!attestation_registered(att))
 		return;
 	evidence = att->evidence_generation > att->evidence_floor || att->verdict_recorded;
@@ -458,8 +457,43 @@ void attestation_state_changed(struct attestation *att)
 		attestation_evidence_event_emit(&events, att);
 	attestation_events_abort(&events);
 }
+EXPORT_SYMBOL_NS_GPL(attestation_state_changed_locked, "ATTESTATION");
+
+void attestation_state_changed(struct attestation *att)
+{
+	guard(mutex)(&att->lock);
+	attestation_state_changed_locked(att);
+}
 EXPORT_SYMBOL_NS_GPL(attestation_state_changed, "ATTESTATION");
 
+void attestation_lock(struct attestation *att)
+{
+	mutex_lock(&att->lock);
+}
+EXPORT_SYMBOL_NS_GPL(attestation_lock, "ATTESTATION");
+
+void attestation_unlock(struct attestation *att)
+{
+	mutex_unlock(&att->lock);
+}
+EXPORT_SYMBOL_NS_GPL(attestation_unlock, "ATTESTATION");
+
+int attestation_state_change_prepare(struct attestation *att)
+{
+	lockdep_assert_held(&att->lock);
+	if (!attestation_registered(att))
+		return -ENODEV;
+	return attestation_preflight(att, true, false, false);
+}
+EXPORT_SYMBOL_NS_GPL(attestation_state_change_prepare, "ATTESTATION");
+
+unsigned int attestation_get_device_generation(struct attestation *att)
+{
+	lockdep_assert_held(&att->lock);
+	return att->device_generation;
+}
+EXPORT_SYMBOL_NS_GPL(attestation_get_device_generation, "ATTESTATION");
+
 static unsigned int attestation_provider_features(const struct attestation_provider *provider)
 {
 	unsigned int features = 0;
diff --git a/include/linux/attestation.h b/include/linux/attestation.h
index 09ebd2af3a1e..0dae626b2e0e 100644
--- a/include/linux/attestation.h
+++ b/include/linux/attestation.h
@@ -299,6 +299,53 @@ void attestation_mr_destroy(struct attestation_mr *mr);
  */
 void attestation_state_changed(struct attestation *att);
 
+/**
+ * attestation_lock - Lock the attestation instance.
+ * @att: attestation instance
+ *
+ * CTLV operations already hold this mutex. Other callers must follow the
+ * same lock order as the provider's CTLV pre-hook.
+ * Do not call while holding an attestation instance mutex.
+ */
+void attestation_lock(struct attestation *att);
+
+/**
+ * attestation_unlock - Release the attestation instance mutex.
+ * @att: attestation instance locked by attestation_lock()
+ */
+void attestation_unlock(struct attestation *att);
+
+/**
+ * attestation_state_change_prepare - Check whether device state can change.
+ * @att: attestation instance
+ *
+ * Call with the instance mutex held, before changing device state.
+ *
+ * Return: 0 on success, -ENODEV if the instance is no longer registered,
+ * or -EOVERFLOW if the device generation cannot be incremented.
+ */
+int attestation_state_change_prepare(struct attestation *att);
+
+/**
+ * attestation_state_changed_locked - Report a device state change.
+ * @att: attestation instance
+ *
+ * Call with the instance mutex held.
+ *
+ * Advance the device generation, invalidate previous evidence and acceptance
+ * verdicts, and emit state-change events. Invalidation still occurs if
+ * allocating the events fails.
+ */
+void attestation_state_changed_locked(struct attestation *att);
+
+/**
+ * attestation_get_device_generation - Read the device generation.
+ * @att: attestation instance
+ *
+ * The caller must hold the instance mutex.
+ */
+unsigned int attestation_get_device_generation(struct attestation *att);
+
 /**
  * attestation_features_set_locked - Set enabled features with the mutex held.
  * @att: attestation instance
-- 
2.43.0