PCI/TSM: Add CTLV attestation

104 lines not on this page · raw message

index b08356c3c027..8f4fa48ffdc5 100644
@@ -60,7 +60,7 @@ static int attestation_device_caps_put(struct attestation *att, struct ctlv_curs
 
 	if (!ctlv_attestation_device_caps_start(reply, &caps_nest))
 		return -EMSGSIZE;
-	if (provider->evidence_caps) {
+	if (att->features & ATTESTATION_FEATURE_EVIDENCE) {
 		const struct attestation_evidence_caps *caps = provider->evidence_caps;
 
 		if (!ctlv_attestation_cap_evidence_start(&caps_nest, &group))

@@ -72,7 +72,7 @@ static int attestation_device_caps_put(struct attestation *att, struct ctlv_curs
 		ok &= ctlv_attestation_cap_max_total_output_length_put(&group,
 								       caps->max_total_output_length);
 		flags = 0;
-		if (provider->evidence_accept)
+		if (att->features & ATTESTATION_FEATURE_EVIDENCE_ACCEPT)
 			flags |= CTLV_ATTESTATION_EVIDENCE_CAPS_EVIDENCE_ACCEPT;
 		if (caps->supports_mr_selection)
 			flags |= CTLV_ATTESTATION_EVIDENCE_CAPS_MR_SELECTION;

@@ -119,7 +119,7 @@ static int attestation_device_caps_put(struct attestation *att, struct ctlv_curs
 		ok &= ctlv_attestation_cap_mr_flags_put(&group, flags);
 		ctlv_nest_end(&group);
 	}
-	if (provider->devsec_run) {
+	if (att->features & ATTESTATION_FEATURE_DEVSEC_RUN) {
 		if (!ctlv_attestation_cap_devsec_start(&caps_nest, &group))
 			return -EMSGSIZE;
 		ok &= ctlv_attestation_cap_devsec_flags_put(&group,

@@ -935,13 +935,13 @@ int ctlv_attestation_devsec_state_get_query(void *priv, struct ctlv_op_ctx *ctx,
 	if (att->verdict_recorded)
 		ok &= ctlv_attestation_evidence_accepted_generation_put(reply,
 									att->accepted_evidence_generation);
-	if (att->provider->tdisp_state_get) {
+	if (att->features & ATTESTATION_FEATURE_TDISP_STATE) {
 		ret = att->provider->tdisp_state_get(att, &state);
 		if (ret)
 			return ret;
 		ok &= ctlv_attestation_devsec_tdisp_state_put(reply, state);
 	}
-	if (att->provider->device_trust_get) {
+	if (att->features & ATTESTATION_FEATURE_DEVICE_TRUST) {
 		ret = att->provider->device_trust_get(att, &trust);
 		if (ret)
 			return ret;

index bd84efb5abb8..9e531e8483f7 100644
@@ -70,6 +70,7 @@ struct attestation_mr_log {
 struct attestation {
 	struct ctlv_device *ctlvdev;
 	const struct attestation_provider *provider;
+	unsigned int features;
 	unsigned int index;
 
 	/* Mutable instance, MR, verdict, and journal state. */

index 911b32255dd5..5882dd2c93a7 100644
@@ -300,15 +300,15 @@ const struct ctlv_op_schema ctlv_attestation_op_schemas[] = {
 	CTLV_OP_SCHEMA_EVENT(CTLV_ATTESTATION_OP_MR_LOG_ENTRY_APPENDED, 73416,
 			     CTLV_SCHEMA_TREE(mr_log_entry_appended_reply)),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT, CTLV_OP_FD_ACCESS_READ_WRITE,
-			      CTLV_OP_AVAILABILITY_FIXED, 64, 0,
+			      CTLV_OP_AVAILABILITY_DYNAMIC, 64, 0,
 			      CTLV_SCHEMA_TREE(evidence_accept_request), CTLV_SCHEMA_TREE_NONE(),
 			      .optional = true),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,
-			      CTLV_OP_FD_ACCESS_READ_WRITE, CTLV_OP_AVAILABILITY_FIXED, 16, 0,
+			      CTLV_OP_FD_ACCESS_READ_WRITE, CTLV_OP_AVAILABILITY_DYNAMIC, 16, 0,
 			      CTLV_SCHEMA_TREE(evidence_accept_clear_request),
 			      CTLV_SCHEMA_TREE_NONE(), .optional = true),
 	CTLV_OP_SCHEMA_QUERY(CTLV_ATTESTATION_OP_DEVSEC_STATE_GET, CTLV_OP_FD_ACCESS_READ,
-			     CTLV_OP_AVAILABILITY_FIXED, 16, 40, 1024,
+			     CTLV_OP_AVAILABILITY_DYNAMIC, 16, 40, 1024,
 			     CTLV_SCHEMA_TREE(devsec_state_get_request),
 			     CTLV_SCHEMA_TREE(devsec_state_get_reply), .optional = true),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_DEVSEC_RUN, CTLV_OP_FD_ACCESS_READ_WRITE,

index 028026a82e8a..a1f125690005 100644
@@ -73,8 +73,14 @@ CTLV_OP_PROVIDE(ctlv_attestation_mr_dump, CTLV_ATTESTATION_OP_MR_DUMP)
 CTLV_OP_PROVIDE(ctlv_attestation_mr_read, CTLV_ATTESTATION_OP_MR_READ)
 CTLV_OP_PROVIDE(ctlv_attestation_mr_extend, CTLV_ATTESTATION_OP_MR_EXTEND)
 CTLV_OP_PROVIDE(ctlv_attestation_evidence_accept, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT)
+CTLV_OP_ENABLE(ctlv_attestation_evidence_accept, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT)
+CTLV_OP_DISABLE(ctlv_attestation_evidence_accept, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT)
 CTLV_OP_PROVIDE(ctlv_attestation_evidence_accept_clear, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR)
+CTLV_OP_ENABLE(ctlv_attestation_evidence_accept_clear, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR)
+CTLV_OP_DISABLE(ctlv_attestation_evidence_accept_clear, CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR)
 CTLV_OP_PROVIDE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
+CTLV_OP_ENABLE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
+CTLV_OP_DISABLE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
 CTLV_OP_PROVIDE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)
 CTLV_OP_ENABLE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)
 CTLV_OP_DISABLE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)

110 lines not on this page · raw message

index ae6ca4024b2a..dede1b53f67a 100644
@@ -14,6 +14,15 @@ struct attestation_mr;
 struct ctlv_blob;
 struct ctlv_cursor;
 
+/* Per-instance subsets of the immutable provider's capabilities. */
+enum attestation_feature {
+	ATTESTATION_FEATURE_EVIDENCE = 1U << 0,
+	ATTESTATION_FEATURE_EVIDENCE_ACCEPT = 1U << 1,
+	ATTESTATION_FEATURE_TDISP_STATE = 1U << 2,
+	ATTESTATION_FEATURE_DEVICE_TRUST = 1U << 3,
+	ATTESTATION_FEATURE_DEVSEC_RUN = 1U << 4,
+};
+
 enum attestation_evidence_representation {
 	ATTESTATION_EVIDENCE_REPRESENTATION_RAW =
 		CTLV_ATTESTATION_EVIDENCE_REPRESENTATION_RAW,

@@ -285,4 +294,28 @@ void attestation_mr_destroy(struct attestation_mr *mr);
  */
 void attestation_state_changed(struct attestation *att);
 
+/**
+ * attestation_features_set_locked - Set enabled features with the mutex held.
+ * @att: attestation instance
+ * @features: features to enable
+ *
+ * The caller must hold the instance mutex.
+ * Update operation availability and DEVICE_GET capabilities together.
+ *
+ * Return: 0 on success, or -EINVAL if the requested features are unsupported
+ * or their dependencies are not satisfied.
+ */
+int attestation_features_set_locked(struct attestation *att, unsigned int features);
+
+/**
+ * attestation_features_set - Set enabled features.
+ * @att: attestation instance
+ * @features: features to enable
+ *
+ * Takes the instance mutex. Follow the same lock order as the CTLV pre-hook.
+ *
+ * Return: 0 on success, or -EINVAL for unsupported features or unmet dependencies.
+ */
+int attestation_features_set(struct attestation *att, unsigned int features);
+
 #endif /* _LINUX_ATTESTATION_H */

index dd558431324e..bccac87ea4fc 100644
@@ -1552,7 +1552,7 @@ static const struct ctlv_op_spec ctlv_attestation_sim_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 64,
 		.request = &evidence_accept_request_node_schema,

@@ -1561,7 +1561,7 @@ static const struct ctlv_op_spec ctlv_attestation_sim_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.request = &evidence_accept_clear_request_node_schema,

@@ -1570,7 +1570,7 @@ static const struct ctlv_op_spec ctlv_attestation_sim_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_DEVSEC_STATE_GET,
 		.type = CTLV_OP_TYPE_QUERY,
 		.fd_access = CTLV_OP_FD_ACCESS_READ,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.query_reply_min_len = 40,

index 50bd181d0d15..3395c0ffc3e5 100644
@@ -1568,7 +1568,7 @@ static const struct ctlv_op_spec ctlv_attestation_tdx_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 64,
 		.request = &evidence_accept_request_node_schema,

@@ -1577,7 +1577,7 @@ static const struct ctlv_op_spec ctlv_attestation_tdx_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.request = &evidence_accept_clear_request_node_schema,

@@ -1586,7 +1586,7 @@ static const struct ctlv_op_spec ctlv_attestation_tdx_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_DEVSEC_STATE_GET,
 		.type = CTLV_OP_TYPE_QUERY,
 		.fd_access = CTLV_OP_FD_ACCESS_READ,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.query_reply_min_len = 40,

index d62affc3a491..6a363b29f80b 100644
@@ -1538,7 +1538,7 @@ static const struct ctlv_op_spec ctlv_attestation_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 64,
 		.request = &evidence_accept_request_node_schema,

@@ -1547,7 +1547,7 @@ static const struct ctlv_op_spec ctlv_attestation_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,
 		.type = CTLV_OP_TYPE_ACTION,
 		.fd_access = CTLV_OP_FD_ACCESS_READ_WRITE,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.request = &evidence_accept_clear_request_node_schema,

@@ -1556,7 +1556,7 @@ static const struct ctlv_op_spec ctlv_attestation_op_specs[] = {
 		.op_id = CTLV_ATTESTATION_OP_DEVSEC_STATE_GET,
 		.type = CTLV_OP_TYPE_QUERY,
 		.fd_access = CTLV_OP_FD_ACCESS_READ,
-		.availability = CTLV_OP_AVAILABILITY_FIXED,
+		.availability = CTLV_OP_AVAILABILITY_DYNAMIC,
 		.optional = true,
 		.request_max_len = 16,
 		.query_reply_min_len = 40,

index 41fe1084c989..37d5d3233cf0 100644
@@ -54,8 +54,12 @@ static int attestation_evidence_caps_validate(const struct attestation_provider
 	const struct attestation_evidence_caps *caps = provider->evidence_caps;
 	size_t object_index;
 
-	if (!caps)
-		return provider->evidence_get ? -EINVAL : 0;
+	if (!caps) {
+		if (provider->evidence_get || provider->evidence_object_supported)
+			return -EINVAL;
+		return 0;
+	}
+
 	if (!provider->evidence_get || !caps->objects || !caps->objects_count ||
 	    caps->objects_count > 16 || caps->min_challenge_length > caps->max_challenge_length ||
 	    caps->max_challenge_length > 4096 || !caps->max_total_output_length)

index 8f4fa48ffdc5..baf9c39f2658 100644
@@ -33,15 +33,20 @@ attestation_representation_in(const struct attestation_evidence_supported_object
 }
 
 static const struct attestation_evidence_supported_object *
-attestation_evidence_object_find(const struct attestation_evidence_caps *caps,
+attestation_evidence_object_find(struct attestation *att,
 				 enum attestation_evidence_blob_class blob_class, bool has_instance,
 				 unsigned int instance, const char *format)
 {
+	const struct attestation_evidence_caps *caps = att->provider->evidence_caps;
 	size_t index;
 
 	for (index = 0; index < caps->objects_count; index++) {
 		const struct attestation_evidence_supported_object *object = &caps->objects[index];
 
+		if (att->provider->evidence_object_supported &&
+		    !att->provider->evidence_object_supported(att, object))
+			continue;
+
 		if (object->blob_class == blob_class && object->has_blob_instance == has_instance &&
 		    (!has_instance || object->blob_instance == instance) &&
 		    !strcmp(object->format, format))

@@ -85,6 +90,10 @@ static int attestation_device_caps_put(struct attestation *att, struct ctlv_curs
 			const struct attestation_evidence_supported_object *cap =
 				&caps->objects[index];
 
+			if (provider->evidence_object_supported &&
+			    !provider->evidence_object_supported(att, cap))
+				continue;
+
 			if (!ctlv_attestation_cap_object_start(&group, &object)) {
 				ok = false;
 				break;

@@ -184,7 +193,7 @@ attestation_evidence_decode_objects(struct attestation *att, struct ctlv_op_ctx
 		if (has_instance)
 			instance = ctlv_attestation_evidence_get_object_evidence_blob_instance_get(
 				&object);
-		supported = attestation_evidence_object_find(caps, blob_class, has_instance,
+		supported = attestation_evidence_object_find(att, blob_class, has_instance,
 							     instance, format);
 		if (!supported || !attestation_representation_in(supported, representation)) {
 			kfree(objects);

index dede1b53f67a..364ab5029277 100644
@@ -233,6 +233,8 @@ struct attestation_evidence_result {
 
 /**
  * struct attestation_provider - Immutable provider operations and properties.
+ * @evidence_object_supported: optionally restrict advertised and requested
+ *	evidence objects per instance; called under the instance lock
  * @evidence_get: produce requested evidence
  * @evidence_accept: record acceptance of the current evidence
  * @evidence_accept_clear: clear a recorded acceptance

@@ -247,6 +249,8 @@ struct attestation_evidence_result {
  * @mrs_count: number of fixed MRs
  */
 struct attestation_provider {
+	bool (*evidence_object_supported)(struct attestation *att,
+		const struct attestation_evidence_supported_object *object);
 	int (*evidence_get)(struct attestation *att,
 			    const struct attestation_evidence_request *request,
 			    struct attestation_evidence_result *result);

index 37d5d3233cf0..a1de19dcab7d 100644
@@ -137,9 +137,6 @@ int attestation_provider_validate(const struct attestation_provider *provider)
 		if (ret)
 			return ret;
 	}
-	if (provider->devsec_run && (!provider->evidence_accept ||
-				     (!provider->tdisp_state_get && !provider->device_trust_get)))
-		return -EINVAL;
 	return 0;
 }
 

@@ -478,9 +475,6 @@ static unsigned int attestation_provider_features(const struct attestation_provi
 	if (provider->device_trust_get)
 		features |= ATTESTATION_FEATURE_DEVICE_TRUST;
 
-	if (provider->devsec_run)
-		features |= ATTESTATION_FEATURE_DEVSEC_RUN;
-
 	return features;
 }
 

@@ -498,10 +492,6 @@ int attestation_features_set_locked(struct attestation *att, unsigned int featur
 	    !(features & ATTESTATION_FEATURE_EVIDENCE))
 		return -EINVAL;
 
-	if ((features & ATTESTATION_FEATURE_DEVSEC_RUN) &&
-	    (!(features & ATTESTATION_FEATURE_EVIDENCE_ACCEPT) || !(features & state)))
-		return -EINVAL;
-
 	att->features = features;
 	if (supported & ATTESTATION_FEATURE_EVIDENCE)
 		ctlv_device_op_state_set(att->ctlvdev, CTLV_ATTESTATION_OP_EVIDENCE_GET,

@@ -520,9 +510,6 @@ int attestation_features_set_locked(struct attestation *att, unsigned int featur
 		ctlv_device_op_state_set(att->ctlvdev, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET,
 					 !(features & state));
 
-	if (supported & ATTESTATION_FEATURE_DEVSEC_RUN)
-		ctlv_device_op_state_set(att->ctlvdev, CTLV_ATTESTATION_OP_DEVSEC_RUN,
-					 !(features & ATTESTATION_FEATURE_DEVSEC_RUN));
 	return 0;
 }
 EXPORT_SYMBOL_NS_GPL(attestation_features_set_locked, "ATTESTATION");

@@ -562,10 +549,6 @@ void attestation_provide_ops(struct attestation *att)
 		ctlv_attestation_devsec_state_get_provide(ctlvdev);
 		ctlv_attestation_devsec_state_get_enable(ctlvdev);
 	}
-	if (provider->devsec_run) {
-		ctlv_attestation_devsec_run_provide(ctlvdev);
-		ctlv_attestation_devsec_run_enable(ctlvdev);
-	}
 }
 
 int attestation_core_init(struct attestation *att, struct ctlv_device *ctlvdev,

60 lines not on this page · raw message

index 5882dd2c93a7..4afd0433e26f 100644
@@ -23,21 +23,18 @@ static const struct ctlv_node_schema device_get_request_node_schemas[] = {
 static const struct ctlv_node_schema device_get_reply_node_schemas[] = {
 	CTLV_NODE_SCHEMA_ROOT(1, 3, 3),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),
-	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_DEVICE_CAPS, 1, 4, 3, 0),
+	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_DEVICE_CAPS, 1, 4, 2, 0),
 	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_DEVICE_INFO, 1, 0, 0, 0),
-	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_EVIDENCE, 1, 7, 5, 4),
-	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_MR, 1, 12, 1, 1),
-	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_DEVSEC, 1, 13, 1, 1),
+	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_EVIDENCE, 1, 6, 5, 4),
+	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_MR, 1, 11, 1, 1),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_CAP_MIN_CHALLENGE_LENGTH, 1, 0, U64_MAX),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_CAP_MAX_CHALLENGE_LENGTH, 1, 0, U64_MAX),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_CAP_MAX_TOTAL_OUTPUT_LENGTH, 1, 0, U64_MAX),
-	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_OBJECT, 16, 14, 6, 4),
+	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_CAP_OBJECT, 16, 12, 6, 4),
 	CTLV_NODE_SCHEMA_FLAGS(CTLV_ATTESTATION_ATTR_CAP_EVIDENCE_FLAGS, 1,
 			       CTLV_ATTESTATION_EVIDENCE_CAPS_MASK),
 	CTLV_NODE_SCHEMA_FLAGS(CTLV_ATTESTATION_ATTR_CAP_MR_FLAGS, 1,
 			       CTLV_ATTESTATION_MR_DEVICE_CAPS_MASK),
-	CTLV_NODE_SCHEMA_FLAGS(CTLV_ATTESTATION_ATTR_CAP_DEVSEC_FLAGS, 1,
-			       CTLV_ATTESTATION_DEVSEC_CAPS_MASK),
 	CTLV_NODE_SCHEMA_ENUM(CTLV_ATTESTATION_ATTR_CAP_BLOB_CLASS, 1, 9),
 	CTLV_NODE_SCHEMA_STRING(CTLV_ATTESTATION_ATTR_CAP_FORMAT, 1, 1, 128),
 	CTLV_NODE_SCHEMA_ENUM(CTLV_ATTESTATION_ATTR_CAP_REPRESENTATION, 2, 2),

@@ -218,17 +215,6 @@ static const struct ctlv_node_schema devsec_state_get_reply_node_schemas[] = {
 	CTLV_NODE_SCHEMA_ENUM(CTLV_ATTESTATION_ATTR_DEVSEC_DEVICE_TRUST, 1, 5),
 };
 
-static const struct ctlv_node_schema devsec_run_request_node_schemas[] = {
-	CTLV_NODE_SCHEMA_ROOT(1, 2, 2),
-	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),
-	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_EVIDENCE_GENERATION, 1, 0, U32_MAX),
-};
-
-static const struct ctlv_node_schema devsec_run_reply_node_schemas[] = {
-	CTLV_NODE_SCHEMA_ROOT(1, 1, 1),
-	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),
-};
-
 static const struct ctlv_node_schema evidence_state_changed_reply_node_schemas[] = {
 	CTLV_NODE_SCHEMA_ROOT(1, 3, 1),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),

@@ -273,7 +259,7 @@ static const struct ctlv_node_schema mr_log_get_reply_node_schemas[] = {
 /* The ops this family declares, in declaration order. */
 const struct ctlv_op_schema ctlv_attestation_op_schemas[] = {
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_DEVICE_GET, CTLV_OP_FD_ACCESS_READ,
-			      CTLV_OP_AVAILABILITY_FIXED, 16, 12936,
+			      CTLV_OP_AVAILABILITY_FIXED, 16, 12896,
 			      CTLV_SCHEMA_TREE(device_get_request),
 			      CTLV_SCHEMA_TREE_STUBS(device_get_reply)),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_EVIDENCE_GET, CTLV_OP_FD_ACCESS_READ_WRITE,

@@ -311,10 +297,6 @@ const struct ctlv_op_schema ctlv_attestation_op_schemas[] = {
 			     CTLV_OP_AVAILABILITY_DYNAMIC, 16, 40, 1024,
 			     CTLV_SCHEMA_TREE(devsec_state_get_request),
 			     CTLV_SCHEMA_TREE(devsec_state_get_reply), .optional = true),
-	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_DEVSEC_RUN, CTLV_OP_FD_ACCESS_READ_WRITE,
-			      CTLV_OP_AVAILABILITY_DYNAMIC, 64, 40,
-			      CTLV_SCHEMA_TREE(devsec_run_request),
-			      CTLV_SCHEMA_TREE(devsec_run_reply), .optional = true),
 	CTLV_OP_SCHEMA_EVENT(CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED, 112,
 			     CTLV_SCHEMA_TREE(evidence_state_changed_reply)),
 	CTLV_OP_SCHEMA_QUERY(CTLV_ATTESTATION_OP_MR_LOG_GET, CTLV_OP_FD_ACCESS_READ,

@@ -351,7 +333,6 @@ static const struct ctlv_op ctlv_attestation_ops[] = {
 	CTLV_OP_ACTION(ctlv_attestation_evidence_accept),
 	CTLV_OP_ACTION(ctlv_attestation_evidence_accept_clear),
 	CTLV_OP_QUERY(ctlv_attestation_devsec_state_get),
-	CTLV_OP_ACTION(ctlv_attestation_devsec_run),
 	CTLV_OP_QUERY(ctlv_attestation_mr_log_get),
 };
 

index a1f125690005..12716a7fa7af 100644
@@ -43,9 +43,6 @@ int ctlv_attestation_evidence_accept_clear_action(void *priv, struct ctlv_op_ctx
 int ctlv_attestation_devsec_state_get_query(void *priv, struct ctlv_op_ctx *ctx,
 					    const struct ctlv_cursor *request,
 					    struct ctlv_cursor *reply);
-int ctlv_attestation_devsec_run_action(void *priv, struct ctlv_op_ctx *ctx,
-				       const struct ctlv_cursor *request,
-				       struct ctlv_cursor *reply);
 int ctlv_attestation_mr_log_get_query(void *priv, struct ctlv_op_ctx *ctx,
 				      const struct ctlv_cursor *request, struct ctlv_cursor *reply);
 

@@ -81,9 +78,6 @@ CTLV_OP_DISABLE(ctlv_attestation_evidence_accept_clear, CTLV_ATTESTATION_OP_EVID
 CTLV_OP_PROVIDE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
 CTLV_OP_ENABLE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
 CTLV_OP_DISABLE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_STATE_GET)
-CTLV_OP_PROVIDE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)
-CTLV_OP_ENABLE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)
-CTLV_OP_DISABLE(ctlv_attestation_devsec_run, CTLV_ATTESTATION_OP_DEVSEC_RUN)
 CTLV_OP_PROVIDE(ctlv_attestation_mr_log_get, CTLV_ATTESTATION_OP_MR_LOG_GET)
 
 /* Reading a validated message. A blob has a resolver instead of a getter. */

@@ -231,29 +225,20 @@ CTLV_IN_REF(ctlv_attestation_evidence_accept_evidence_generation,
 	    1, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_evidence_accept_evidence_generation)
 CTLV_IN_U64(ctlv_attestation_evidence_accept_evidence_generation)
-CTLV_IN_REF(ctlv_attestation_devsec_run_device_generation, &ctlv_attestation_op_schemas[11].request,
-	    CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 0, 0, CTLV_SCHEMA_UINT)
-CTLV_IN_HAS(ctlv_attestation_devsec_run_device_generation)
-CTLV_IN_U64(ctlv_attestation_devsec_run_device_generation)
-CTLV_IN_REF(ctlv_attestation_devsec_run_evidence_generation,
-	    &ctlv_attestation_op_schemas[11].request, CTLV_ATTESTATION_ATTR_EVIDENCE_GENERATION, 0,
-	    1, CTLV_SCHEMA_UINT)
-CTLV_IN_HAS(ctlv_attestation_devsec_run_evidence_generation)
-CTLV_IN_U64(ctlv_attestation_devsec_run_evidence_generation)
-CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_selection, &ctlv_attestation_op_schemas[13].request,
+CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_selection, &ctlv_attestation_op_schemas[12].request,
 	    CTLV_ATTESTATION_ATTR_MR_SELECTION, 0, 0, CTLV_SCHEMA_NEST)
 #define ctlv_attestation_mr_log_get_mr_selection_for_each(_attr, _nest) \
 	CTLV_IN_FOR_EACH(ctlv_attestation_mr_log_get_mr_selection, _attr, _nest)
 CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_start_generation,
-	    &ctlv_attestation_op_schemas[13].request, CTLV_ATTESTATION_ATTR_MR_START_GENERATION, 0,
+	    &ctlv_attestation_op_schemas[12].request, CTLV_ATTESTATION_ATTR_MR_START_GENERATION, 0,
 	    1, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_mr_log_get_mr_start_generation)
 CTLV_IN_U64(ctlv_attestation_mr_log_get_mr_start_generation)
-CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_end_generation, &ctlv_attestation_op_schemas[13].request,
+CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_end_generation, &ctlv_attestation_op_schemas[12].request,
 	    CTLV_ATTESTATION_ATTR_MR_END_GENERATION, 0, 2, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_mr_log_get_mr_end_generation)
 CTLV_IN_U64(ctlv_attestation_mr_log_get_mr_end_generation)
-CTLV_IN_REF(ctlv_attestation_mr_log_get_selection_mr_id, &ctlv_attestation_op_schemas[13].request,
+CTLV_IN_REF(ctlv_attestation_mr_log_get_selection_mr_id, &ctlv_attestation_op_schemas[12].request,
 	    CTLV_ATTESTATION_ATTR_MR_ID, 1, 0, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_mr_log_get_selection_mr_id)
 CTLV_IN_U64(ctlv_attestation_mr_log_get_selection_mr_id)

@@ -282,9 +267,6 @@ CTLV_PUT_U64(ctlv_attestation_cap_max_length, CTLV_ATTESTATION_ATTR_CAP_MAX_LENG
 	     CTLV_SCHEMA_UINT)
 CTLV_PUT_U64(ctlv_attestation_cap_evidence_flags, CTLV_ATTESTATION_ATTR_CAP_EVIDENCE_FLAGS,
 	     CTLV_SCHEMA_FLAGS)
-CTLV_NEST_START(ctlv_attestation_cap_devsec, CTLV_ATTESTATION_ATTR_CAP_DEVSEC, CTLV_SCHEMA_NEST)
-CTLV_PUT_U64(ctlv_attestation_cap_devsec_flags, CTLV_ATTESTATION_ATTR_CAP_DEVSEC_FLAGS,
-	     CTLV_SCHEMA_FLAGS)
 CTLV_PUT_U64(ctlv_attestation_cap_blob_instance, CTLV_ATTESTATION_ATTR_CAP_BLOB_INSTANCE,
 	     CTLV_SCHEMA_UINT)
 CTLV_PUT_U64(ctlv_attestation_cap_hash_algo, CTLV_ATTESTATION_ATTR_CAP_HASH_ALGO, CTLV_SCHEMA_UINT)

index 5cf312285e85..7c35b1611f10 100644
@@ -33,7 +33,6 @@ enum attestation_sim_callback {
 	ATTESTATION_SIM_CB_MR_EXTEND,
 	ATTESTATION_SIM_CB_TDISP_STATE_GET,
 	ATTESTATION_SIM_CB_DEVICE_TRUST_GET,
-	ATTESTATION_SIM_CB_DEVSEC_RUN,
 	ATTESTATION_SIM_CB_COUNT,
 };
 

@@ -55,7 +54,6 @@ struct attestation_sim {
 	struct attestation_sim_mr fixed[2];
 	enum attestation_tdisp_state tdisp_state;
 	enum attestation_device_trust_state trust_state;
-	bool pending_verdict;
 	bool notification_pending;
 };
 

@@ -196,7 +194,6 @@ static const char * const attestation_sim_callback_names[] = {
 	[ATTESTATION_SIM_CB_MR_EXTEND] = "mr_extend",
 	[ATTESTATION_SIM_CB_TDISP_STATE_GET] = "tdisp_state_get",
 	[ATTESTATION_SIM_CB_DEVICE_TRUST_GET] = "device_trust_get",
-	[ATTESTATION_SIM_CB_DEVSEC_RUN] = "devsec_run",
 };
 
 static enum attestation_sim_callback

@@ -585,16 +582,16 @@ static int attestation_sim_evidence_accept(struct attestation *att)
 	guard(mutex)(&sim->hardware_lock);
 	if (sim->notification_pending)
 		return -EAGAIN;
-	sim->pending_verdict = true;
+	if (sim->tdisp_state != ATTESTATION_TDISP_STATE_LOCKED &&
+	    sim->tdisp_state != ATTESTATION_TDISP_STATE_RUN)
+		return -EACCES;
+	sim->tdisp_state = ATTESTATION_TDISP_STATE_RUN;
 	return 0;
 }
 
 static void attestation_sim_evidence_accept_clear(struct attestation *att)
 {
-	struct attestation_sim *sim = attestation_sim_from_att(att);
-
-	guard(mutex)(&sim->hardware_lock);
-	sim->pending_verdict = false;
+	/* The common core owns the verdict; clearing it does not leave RUN. */
 }
 
 static int

@@ -633,26 +630,6 @@ attestation_sim_device_trust_get(
 	return 0;
 }
 
-static int attestation_sim_devsec_run(struct attestation *att)
-{
-	struct attestation_sim *sim = attestation_sim_from_att(att);
-	int ret;
-
-	ret = attestation_sim_callback_enter(
-		sim, ATTESTATION_SIM_CB_DEVSEC_RUN);
-	if (ret)
-		return ret;
-	guard(mutex)(&sim->hardware_lock);
-	if (sim->notification_pending)
-		return -EAGAIN;
-	if (sim->tdisp_state != ATTESTATION_TDISP_STATE_LOCKED ||
-	    !sim->pending_verdict)
-		return -EACCES;
-	sim->tdisp_state = ATTESTATION_TDISP_STATE_RUN;
-	sim->pending_verdict = false;
-	return 0;
-}
-
 static const struct attestation_provider attestation_sim_provider = {
 	.evidence_get = attestation_sim_evidence_get,
 	.evidence_accept = attestation_sim_evidence_accept,

@@ -661,7 +638,6 @@ static const struct attestation_provider attestation_sim_provider = {
 	.mr_extend = attestation_sim_mr_extend,
 	.tdisp_state_get = attestation_sim_tdisp_state_get,
 	.device_trust_get = attestation_sim_device_trust_get,
-	.devsec_run = attestation_sim_devsec_run,
 	.evidence_caps = &attestation_sim_evidence_caps,
 	.mr_caps = &attestation_sim_mr_caps,
 	.mrs = attestation_sim_mrs,

@@ -937,7 +913,6 @@ static ssize_t attestation_sim_state_write(struct file *file,
 		fixture->sim->notification_pending = true;
 		fixture->sim->tdisp_state = tdisp;
 		fixture->sim->trust_state = trust;
-		fixture->sim->pending_verdict = false;
 	}
 	att = ctlv_priv_parent(fixture->sim);
 	attestation_state_changed(att);

index 7e4710370cfe..08cb5eabee1b 100644
@@ -231,7 +231,7 @@ static void attestation_test_instance_features(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, fixture->att->features, features);
 	/* A child cannot enable a callback that its provider did not supply. */
 	KUNIT_EXPECT_EQ(test, attestation_features_set(fixture->att,
-			features | ATTESTATION_FEATURE_DEVSEC_RUN), -EINVAL);
+			features | ATTESTATION_FEATURE_TDISP_STATE), -EINVAL);
 	KUNIT_EXPECT_EQ(test, fixture->att->features, features);
 	KUNIT_ASSERT_EQ(test, attestation_features_set(fixture->att, 0), 0);
 	KUNIT_EXPECT_EQ(test, fixture->att->features, 0U);

@@ -250,36 +250,21 @@ static int attestation_test_tdisp_state(struct attestation *att,
 	return 0;
 }
 
-static int attestation_test_run(struct attestation *att)
-{
-	return 0;
-}
-
 static void attestation_test_secure_features(struct kunit *test)
 {
 	struct attestation_test *fixture = test->priv;
 	unsigned int evidence = ATTESTATION_FEATURE_EVIDENCE |
 				ATTESTATION_FEATURE_EVIDENCE_ACCEPT;
 	unsigned int state = ATTESTATION_FEATURE_TDISP_STATE;
-	unsigned int run = ATTESTATION_FEATURE_DEVSEC_RUN;
 
 	attestation_test_provider_init(fixture);
 	fixture->provider.tdisp_state_get = attestation_test_tdisp_state;
-	fixture->provider.devsec_run = attestation_test_run;
 	KUNIT_ASSERT_EQ(test, attestation_test_create_provider(
 				test, fixture, "attestation-secure-features"), 0);
-	KUNIT_EXPECT_EQ(test, fixture->att->features, evidence | state | run);
-	KUNIT_EXPECT_EQ(test, attestation_features_set(fixture->att, run), -EINVAL);
-	KUNIT_EXPECT_EQ(test, attestation_features_set(fixture->att,
-			evidence | run), -EINVAL);
-	KUNIT_EXPECT_EQ(test, attestation_features_set(fixture->att,
-			state | run), -EINVAL);
+	KUNIT_EXPECT_EQ(test, fixture->att->features, evidence | state);
 	/* Unlocked, locked, RUN, and host verdict-only capability sets. */
 	KUNIT_ASSERT_EQ(test, attestation_features_set(fixture->att, state), 0);
 	KUNIT_EXPECT_EQ(test, fixture->att->features, state);
-	KUNIT_ASSERT_EQ(test, attestation_features_set(fixture->att,
-			evidence | state | run), 0);
-	KUNIT_EXPECT_EQ(test, fixture->att->features, evidence | state | run);
 	KUNIT_ASSERT_EQ(test, attestation_features_set(fixture->att,
 			evidence | state), 0);
 	KUNIT_EXPECT_EQ(test, fixture->att->features, evidence | state);

index 364ab5029277..9813361ddd29 100644
@@ -20,7 +20,6 @@ enum attestation_feature {
 	ATTESTATION_FEATURE_EVIDENCE_ACCEPT = 1U << 1,
 	ATTESTATION_FEATURE_TDISP_STATE = 1U << 2,
 	ATTESTATION_FEATURE_DEVICE_TRUST = 1U << 3,
-	ATTESTATION_FEATURE_DEVSEC_RUN = 1U << 4,
 };
 
 enum attestation_evidence_representation {

@@ -236,13 +235,12 @@ struct attestation_evidence_result {
  * @evidence_object_supported: optionally restrict advertised and requested
  *	evidence objects per instance; called under the instance lock
  * @evidence_get: produce requested evidence
- * @evidence_accept: record acceptance of the current evidence
+ * @evidence_accept: accept current evidence and enable secure operation
  * @evidence_accept_clear: clear a recorded acceptance
  * @mr_read: read one MR
  * @mr_extend: extend one MR
  * @tdisp_state_get: get the TDISP state
  * @device_trust_get: get the provider trust state
- * @devsec_run: enter the provider's secure state
  * @evidence_caps: evidence capabilities, or NULL
  * @mr_caps: MR capabilities, or NULL
  * @mrs: fixed MR properties

@@ -266,7 +264,6 @@ struct attestation_provider {
 			       enum attestation_tdisp_state *state);
 	int (*device_trust_get)(struct attestation *att,
 				enum attestation_device_trust_state *trust);
-	int (*devsec_run)(struct attestation *att);
 	const struct attestation_evidence_caps *evidence_caps;
 	const struct attestation_mr_caps *mr_caps;
 	const struct attestation_mr_props *mrs;

index 2921bea50151..627c6f5f9377 100644
@@ -100,14 +100,6 @@ enum _ctlv_attestation_mr_state_flags_bit {
 	_BITULL(CTLV_ATTESTATION_MR_STATE_FLAGS_IMA_ACTIVE_BIT)
 #define CTLV_ATTESTATION_MR_STATE_FLAGS_MASK CTLV_ATTESTATION_MR_STATE_FLAGS_IMA_ACTIVE
 
-/* flags devsec-caps */
-enum _ctlv_attestation_devsec_caps_bit {
-	CTLV_ATTESTATION_DEVSEC_CAPS_RUN_BIT,
-};
-
-#define CTLV_ATTESTATION_DEVSEC_CAPS_RUN _BITULL(CTLV_ATTESTATION_DEVSEC_CAPS_RUN_BIT)
-#define CTLV_ATTESTATION_DEVSEC_CAPS_MASK CTLV_ATTESTATION_DEVSEC_CAPS_RUN
-
 /* flags evidence-caps */
 enum _ctlv_attestation_evidence_caps_bit {
 	CTLV_ATTESTATION_EVIDENCE_CAPS_EVIDENCE_ACCEPT_BIT,

@@ -174,8 +166,6 @@ enum _ctlv_attestation_attr_cap {
 	_CTLV_ATTESTATION_ATTR_CAP_REPRESENTATION,
 	_CTLV_ATTESTATION_ATTR_CAP_MAX_LENGTH,
 	_CTLV_ATTESTATION_ATTR_CAP_EVIDENCE_FLAGS,
-	_CTLV_ATTESTATION_ATTR_CAP_DEVSEC,
-	_CTLV_ATTESTATION_ATTR_CAP_DEVSEC_FLAGS,
 	_CTLV_ATTESTATION_ATTR_CAP_BLOB_INSTANCE,
 	_CTLV_ATTESTATION_ATTR_CAP_HASH_ALGO,
 };

@@ -195,8 +185,6 @@ enum _ctlv_attestation_attr_cap {
 #define CTLV_ATTESTATION_ATTR_CAP_REPRESENTATION _CTLV_ATTESTATION_ATTR_CAP(REPRESENTATION)
 #define CTLV_ATTESTATION_ATTR_CAP_MAX_LENGTH _CTLV_ATTESTATION_ATTR_CAP(MAX_LENGTH)
 #define CTLV_ATTESTATION_ATTR_CAP_EVIDENCE_FLAGS _CTLV_ATTESTATION_ATTR_CAP(EVIDENCE_FLAGS)
-#define CTLV_ATTESTATION_ATTR_CAP_DEVSEC _CTLV_ATTESTATION_ATTR_CAP(DEVSEC)
-#define CTLV_ATTESTATION_ATTR_CAP_DEVSEC_FLAGS _CTLV_ATTESTATION_ATTR_CAP(DEVSEC_FLAGS)
 #define CTLV_ATTESTATION_ATTR_CAP_BLOB_INSTANCE _CTLV_ATTESTATION_ATTR_CAP(BLOB_INSTANCE)
 #define CTLV_ATTESTATION_ATTR_CAP_HASH_ALGO _CTLV_ATTESTATION_ATTR_CAP(HASH_ALGO)
 

@@ -368,10 +356,8 @@ enum _ctlv_attestation_set {
 	CTLV_ATTESTATION_SET_DEVICE_STATE_EVENT,
 	CTLV_ATTESTATION_SET_MR_LOG_EVENT,
 	CTLV_ATTESTATION_SET_MR_LOG_IMA,
-	CTLV_ATTESTATION_SET_DEVSEC_CAP,
 	CTLV_ATTESTATION_SET_EVIDENCE_GENERATION_REQUEST,
 	CTLV_ATTESTATION_SET_DEVSEC_STATE_REPLY,
-	CTLV_ATTESTATION_SET_DEVSEC_RUN_REPLY,
 	CTLV_ATTESTATION_SET_EVIDENCE_STATE_EVENT,
 	CTLV_ATTESTATION_SET_EVIDENCE_OPTIONS,
 	CTLV_ATTESTATION_SET_MR_OPTIONS,

@@ -395,7 +381,6 @@ enum _ctlv_attestation_op {
 	_CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT,
 	_CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,
 	_CTLV_ATTESTATION_OP_DEVSEC_STATE_GET,
-	_CTLV_ATTESTATION_OP_DEVSEC_RUN,
 	_CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED,
 	_CTLV_ATTESTATION_OP_MR_LOG_GET,
 };

@@ -412,7 +397,6 @@ enum _ctlv_attestation_op {
 #define CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT _CTLV_ATTESTATION_OP(EVIDENCE_ACCEPT)
 #define CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR _CTLV_ATTESTATION_OP(EVIDENCE_ACCEPT_CLEAR)
 #define CTLV_ATTESTATION_OP_DEVSEC_STATE_GET _CTLV_ATTESTATION_OP(DEVSEC_STATE_GET)
-#define CTLV_ATTESTATION_OP_DEVSEC_RUN _CTLV_ATTESTATION_OP(DEVSEC_RUN)
 #define CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED _CTLV_ATTESTATION_OP(EVIDENCE_STATE_CHANGED)
 #define CTLV_ATTESTATION_OP_MR_LOG_GET _CTLV_ATTESTATION_OP(MR_LOG_GET)
 

index 5f1caaac859e..bd831b0ef14f 100644
@@ -154,7 +154,7 @@ FIXTURE_TEARDOWN(attestation)
 
 TEST_F(attestation, discovery_and_caps)
 {
-	const struct ctlv_attr *caps, *evidence, *mr, *devsec, *info;
+	const struct ctlv_attr *caps, *evidence, *mr, *info;
 	struct ctlv_reply *reply;
 	const char *name = NULL;
 	__u64 generation = 1;

@@ -175,10 +175,8 @@ TEST_F(attestation, discovery_and_caps)
 	ASSERT_NE(NULL, caps);
 	evidence = ctlv_attestation_cap_evidence_get(caps);
 	mr = ctlv_attestation_cap_mr_get(caps);
-	devsec = ctlv_attestation_cap_devsec_get(caps);
 	ASSERT_NE(NULL, evidence);
 	ASSERT_NE(NULL, mr);
-	ASSERT_NE(NULL, devsec);
 	EXPECT_TRUE(ctlv_attestation_cap_evidence_flags_get(evidence, &flags,
 							    &unknown));
 	EXPECT_EQ(0, unknown);

@@ -526,6 +524,7 @@ TEST_F(attestation, evidence_verdict_and_run)
 		unsigned char data[EVIDENCE_MAX];
 	} output;
 	struct ctlv_reply *reply;
+	const struct ctlv_attr *root;
 	struct ctlv_msg *request;
 	const __u64 subscriptions[] = {
 		CTLV_ATTESTATION_OP_DEVICE_STATE_CHANGED,

@@ -557,6 +556,13 @@ TEST_F(attestation, evidence_verdict_and_run)
 	expect_event(_metadata, self->dev,
 		     CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED);
 
+	ASSERT_EQ(0, ctlv_attestation_devsec_state_get(self->dev, NULL, &reply, &self->error));
+	root = ctlv_reply_root(reply);
+	EXPECT_TRUE(ctlv_attestation_devsec_tdisp_state_get(root, &state, &known));
+	EXPECT_TRUE(known);
+	EXPECT_EQ(CTLV_ATTESTATION_TDISP_STATE_RUN, state);
+	ctlv_reply_free(reply);
+
 	ASSERT_EQ(0,
 		  ctlv_attestation_evidence_accept_clear_request_new(&request));
 	ASSERT_EQ(0, ctlv_attestation_evidence_accept_clear(

@@ -569,22 +575,6 @@ TEST_F(attestation, evidence_verdict_and_run)
 	expect_event(_metadata, self->dev,
 		     CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED);
 
-	ASSERT_EQ(0, ctlv_attestation_devsec_run_request_new(&request));
-	ctlv_attestation_device_generation_put(request, device_generation);
-	ctlv_attestation_evidence_generation_put(
-		request, evidence_generation);
-	ASSERT_EQ(0, ctlv_attestation_devsec_run(
-			  self->dev, request, &reply, &self->error));
-	ctlv_msg_free(request);
-	EXPECT_TRUE(ctlv_attestation_device_generation_get(
-		ctlv_reply_root(reply), &device_generation));
-	EXPECT_EQ(2, device_generation);
-	ctlv_reply_free(reply);
-	expect_event(_metadata, self->dev,
-		     CTLV_ATTESTATION_OP_DEVICE_STATE_CHANGED);
-	expect_event(_metadata, self->dev,
-		     CTLV_ATTESTATION_OP_EVIDENCE_STATE_CHANGED);
-
 	ASSERT_EQ(0, ctlv_attestation_devsec_state_get(
 			  self->dev, NULL, &reply, &self->error));
 	EXPECT_TRUE(ctlv_attestation_devsec_tdisp_state_get(

123 lines not on this page · raw message

123 lines not on this page · raw message

123 lines not on this page · raw message

76 lines not on this page · raw message

index a1de19dcab7d..914f29693aee 100644
@@ -248,6 +248,7 @@ void attestation_evidence_accept_clear_locked(struct attestation *att)
 		return;
 	att->provider->evidence_accept_clear(att);
 	att->verdict_recorded = false;
+	att->accepted_object = NULL;
 }
 
 static void attestation_evidence_ranges_clear(struct attestation *att, bool dependent_only)

183 lines not on this page · raw message

index 9e531e8483f7..7b444d61d996 100644
@@ -25,6 +25,7 @@ struct attestation_evidence_range {
 	unsigned int end_generation;
 	bool mr_dependent;
 	unsigned int mr_generation;
+	unsigned long objects[];
 };
 
 struct attestation_mr_log_entry {

@@ -82,6 +83,7 @@ struct attestation {
 	bool verdict_recorded;
 	unsigned int accepted_device_generation;
 	unsigned int accepted_evidence_generation;
+	const struct attestation_evidence_supported_object *accepted_object;
 	unsigned int mr_read_generation;
 	unsigned int devsec_version;
 

index 4afd0433e26f..a858a84da135 100644
@@ -193,9 +193,13 @@ static const struct ctlv_node_schema mr_log_entry_appended_reply_node_schemas[]
 };
 
 static const struct ctlv_node_schema evidence_accept_request_node_schemas[] = {
-	CTLV_NODE_SCHEMA_ROOT(1, 2, 2),
+	CTLV_NODE_SCHEMA_ROOT(1, 3, 2),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_EVIDENCE_GENERATION, 1, 0, U32_MAX),
+	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT, 1, 4, 3, 2),
+	CTLV_NODE_SCHEMA_ENUM(CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_CLASS, 1, 9),
+	CTLV_NODE_SCHEMA_STRING(CTLV_ATTESTATION_ATTR_EVIDENCE_FORMAT, 1, 1, 128),
+	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_INSTANCE, 1, 0, U32_MAX),
 };
 
 static const struct ctlv_node_schema evidence_accept_clear_request_node_schemas[] = {

@@ -286,7 +290,7 @@ const struct ctlv_op_schema ctlv_attestation_op_schemas[] = {
 	CTLV_OP_SCHEMA_EVENT(CTLV_ATTESTATION_OP_MR_LOG_ENTRY_APPENDED, 73416,
 			     CTLV_SCHEMA_TREE(mr_log_entry_appended_reply)),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT, CTLV_OP_FD_ACCESS_READ_WRITE,
-			      CTLV_OP_AVAILABILITY_DYNAMIC, 64, 0,
+			      CTLV_OP_AVAILABILITY_DYNAMIC, 280, 0,
 			      CTLV_SCHEMA_TREE(evidence_accept_request), CTLV_SCHEMA_TREE_NONE(),
 			      .optional = true),
 	CTLV_OP_SCHEMA_ACTION(CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_CLEAR,

index 12716a7fa7af..95cb6a083633 100644
@@ -225,6 +225,26 @@ CTLV_IN_REF(ctlv_attestation_evidence_accept_evidence_generation,
 	    1, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_evidence_accept_evidence_generation)
 CTLV_IN_U64(ctlv_attestation_evidence_accept_evidence_generation)
+CTLV_IN_REF(ctlv_attestation_evidence_accept_evidence_accept_object,
+	    &ctlv_attestation_op_schemas[8].request, CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT,
+	    0, 2, CTLV_SCHEMA_NEST)
+CTLV_IN_HAS(ctlv_attestation_evidence_accept_evidence_accept_object)
+CTLV_IN_NEST(ctlv_attestation_evidence_accept_evidence_accept_object)
+CTLV_IN_REF(ctlv_attestation_evidence_accept_accept_object_evidence_blob_class,
+	    &ctlv_attestation_op_schemas[8].request, CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_CLASS, 3,
+	    0, CTLV_SCHEMA_ENUM)
+CTLV_IN_HAS(ctlv_attestation_evidence_accept_accept_object_evidence_blob_class)
+CTLV_IN_U64(ctlv_attestation_evidence_accept_accept_object_evidence_blob_class)
+CTLV_IN_REF(ctlv_attestation_evidence_accept_accept_object_evidence_format,
+	    &ctlv_attestation_op_schemas[8].request, CTLV_ATTESTATION_ATTR_EVIDENCE_FORMAT, 3, 1,
+	    CTLV_SCHEMA_STRING)
+CTLV_IN_HAS(ctlv_attestation_evidence_accept_accept_object_evidence_format)
+CTLV_IN_STRING(ctlv_attestation_evidence_accept_accept_object_evidence_format)
+CTLV_IN_REF(ctlv_attestation_evidence_accept_accept_object_evidence_blob_instance,
+	    &ctlv_attestation_op_schemas[8].request, CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_INSTANCE,
+	    3, 2, CTLV_SCHEMA_UINT)
+CTLV_IN_HAS(ctlv_attestation_evidence_accept_accept_object_evidence_blob_instance)
+CTLV_IN_U64(ctlv_attestation_evidence_accept_accept_object_evidence_blob_instance)
 CTLV_IN_REF(ctlv_attestation_mr_log_get_mr_selection, &ctlv_attestation_op_schemas[12].request,
 	    CTLV_ATTESTATION_ATTR_MR_SELECTION, 0, 0, CTLV_SCHEMA_NEST)
 #define ctlv_attestation_mr_log_get_mr_selection_for_each(_attr, _nest) \

@@ -302,6 +322,8 @@ CTLV_PUT_U64(ctlv_attestation_evidence_service_manifest_version,
 	     CTLV_ATTESTATION_ATTR_EVIDENCE_SERVICE_MANIFEST_VERSION, CTLV_SCHEMA_UINT)
 CTLV_NEST_START(ctlv_attestation_evidence_options, CTLV_ATTESTATION_ATTR_EVIDENCE_OPTIONS,
 		CTLV_SCHEMA_NEST)
+CTLV_NEST_START(ctlv_attestation_evidence_accept_object,
+		CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT, CTLV_SCHEMA_NEST)
 CTLV_PUT_U64(ctlv_attestation_mr_id, CTLV_ATTESTATION_ATTR_MR_ID, CTLV_SCHEMA_UINT)
 CTLV_PUT_STRING(ctlv_attestation_mr_name, CTLV_ATTESTATION_ATTR_MR_NAME, CTLV_SCHEMA_STRING)
 CTLV_PUT_U64(ctlv_attestation_mr_hash_algo, CTLV_ATTESTATION_ATTR_MR_HASH_ALGO, CTLV_SCHEMA_UINT)

index 7c35b1611f10..4a541462dc7e 100644
@@ -179,6 +179,7 @@ static const struct attestation_evidence_caps attestation_sim_evidence_caps = {
 	.supports_mr_selection = true,
 	.supports_privlevel = true,
 	.supports_service_attestation = true,
+	.supports_object_accept = true,
 	.objects = attestation_sim_evidence_objects,
 	.objects_count = ARRAY_SIZE(attestation_sim_evidence_objects),
 };

@@ -570,7 +571,9 @@ attestation_sim_evidence_get(struct attestation *att,
 	return ret;
 }
 
-static int attestation_sim_evidence_accept(struct attestation *att)
+static int
+attestation_sim_evidence_accept(struct attestation *att,
+		const struct attestation_evidence_supported_object *object)
 {
 	struct attestation_sim *sim = attestation_sim_from_att(att);
 	int ret;

index 08cb5eabee1b..898f5b34d32f 100644
@@ -95,7 +95,9 @@ attestation_test_evidence_get(
 	return 0;
 }
 
-static int attestation_test_evidence_accept(struct attestation *att)
+static int
+attestation_test_evidence_accept(struct attestation *att,
+		const struct attestation_evidence_supported_object *object)
 {
 	return 0;
 }

index 9813361ddd29..09ebd2af3a1e 100644
@@ -154,6 +154,7 @@ struct attestation_evidence_supported_object {
  * @supports_mr_selection: requests may select MRs
  * @supports_privlevel: requests may select a privilege level
  * @supports_service_attestation: requests may identify a service
+ * @supports_object_accept: acceptance may select an object from its snapshot
  * @objects: supported evidence objects
  * @objects_count: number of objects
  */

@@ -164,6 +165,7 @@ struct attestation_evidence_caps {
 	bool supports_mr_selection;
 	bool supports_privlevel;
 	bool supports_service_attestation;
+	bool supports_object_accept;
 	const struct attestation_evidence_supported_object *objects;
 	size_t objects_count;
 };

@@ -235,7 +237,8 @@ struct attestation_evidence_result {
  * @evidence_object_supported: optionally restrict advertised and requested
  *	evidence objects per instance; called under the instance lock
  * @evidence_get: produce requested evidence
- * @evidence_accept: accept current evidence and enable secure operation
+ * @evidence_accept: accept evidence and enable secure operation; the optional
+ *		   object selector belongs to the referenced evidence snapshot
  * @evidence_accept_clear: clear a recorded acceptance
  * @mr_read: read one MR
  * @mr_extend: extend one MR

@@ -252,7 +255,8 @@ struct attestation_provider {
 	int (*evidence_get)(struct attestation *att,
 			    const struct attestation_evidence_request *request,
 			    struct attestation_evidence_result *result);
-	int (*evidence_accept)(struct attestation *att);
+	int (*evidence_accept)(struct attestation *att,
+		const struct attestation_evidence_supported_object *object);
 	void (*evidence_accept_clear)(struct attestation *att);
 	int (*mr_read)(struct attestation *att, unsigned int mr_id,
 		       const struct ctlv_cursor *mr_options,

index 627c6f5f9377..f993def4fe57 100644
@@ -106,6 +106,7 @@ enum _ctlv_attestation_evidence_caps_bit {
 	CTLV_ATTESTATION_EVIDENCE_CAPS_MR_SELECTION_BIT,
 	CTLV_ATTESTATION_EVIDENCE_CAPS_PRIVLEVEL_BIT,
 	CTLV_ATTESTATION_EVIDENCE_CAPS_SERVICE_BIT,
+	CTLV_ATTESTATION_EVIDENCE_CAPS_OBJECT_SELECTION_BIT,
 };
 
 #define CTLV_ATTESTATION_EVIDENCE_CAPS_EVIDENCE_ACCEPT \

@@ -115,11 +116,14 @@ enum _ctlv_attestation_evidence_caps_bit {
 #define CTLV_ATTESTATION_EVIDENCE_CAPS_PRIVLEVEL \
 	_BITULL(CTLV_ATTESTATION_EVIDENCE_CAPS_PRIVLEVEL_BIT)
 #define CTLV_ATTESTATION_EVIDENCE_CAPS_SERVICE _BITULL(CTLV_ATTESTATION_EVIDENCE_CAPS_SERVICE_BIT)
+#define CTLV_ATTESTATION_EVIDENCE_CAPS_OBJECT_SELECTION \
+	_BITULL(CTLV_ATTESTATION_EVIDENCE_CAPS_OBJECT_SELECTION_BIT)
 #define CTLV_ATTESTATION_EVIDENCE_CAPS_MASK \
 	(CTLV_ATTESTATION_EVIDENCE_CAPS_EVIDENCE_ACCEPT | \
 	 CTLV_ATTESTATION_EVIDENCE_CAPS_MR_SELECTION | \
 	 CTLV_ATTESTATION_EVIDENCE_CAPS_PRIVLEVEL | \
-	 CTLV_ATTESTATION_EVIDENCE_CAPS_SERVICE)
+	 CTLV_ATTESTATION_EVIDENCE_CAPS_SERVICE | \
+	 CTLV_ATTESTATION_EVIDENCE_CAPS_OBJECT_SELECTION)
 
 /* attr groups */
 enum _ctlv_attestation_group {

@@ -211,6 +215,7 @@ enum _ctlv_attestation_attr_evidence {
 	_CTLV_ATTESTATION_ATTR_EVIDENCE_SERVICE_GUID,
 	_CTLV_ATTESTATION_ATTR_EVIDENCE_SERVICE_MANIFEST_VERSION,
 	_CTLV_ATTESTATION_ATTR_EVIDENCE_OPTIONS,
+	_CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT,
 };
 
 #define CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE _CTLV_ATTESTATION_ATTR_EVIDENCE(CHALLENGE)

@@ -234,6 +239,7 @@ enum _ctlv_attestation_attr_evidence {
 #define CTLV_ATTESTATION_ATTR_EVIDENCE_SERVICE_MANIFEST_VERSION \
 	_CTLV_ATTESTATION_ATTR_EVIDENCE(SERVICE_MANIFEST_VERSION)
 #define CTLV_ATTESTATION_ATTR_EVIDENCE_OPTIONS _CTLV_ATTESTATION_ATTR_EVIDENCE(OPTIONS)
+#define CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT _CTLV_ATTESTATION_ATTR_EVIDENCE(ACCEPT_OBJECT)
 
 /* attrs of group mr */
 #define _CTLV_ATTESTATION_ATTR_MR(_attr) \

@@ -366,6 +372,7 @@ enum _ctlv_attestation_set {
 	CTLV_ATTESTATION_SET_MR_LOG_SELECTION,
 	CTLV_ATTESTATION_SET_MR_LOG_REQUEST,
 	CTLV_ATTESTATION_SET_MR_LOG_REPLY,
+	CTLV_ATTESTATION_SET_EVIDENCE_OBJECT_SELECTOR,
 };
 
 /* ops */

82 lines not on this page · raw message

82 lines not on this page · raw message

82 lines not on this page · raw message

index 67b8820b3efc..88d8ac5048d8 100644
@@ -115,7 +115,7 @@ static inline int ctlv_attestation_mr_extend(struct ctlv_dev *dev, struct ctlv_m
 	return ctlv_action(dev, CTLV_ATTESTATION_OP_MR_EXTEND, request, reply, error);
 }
 
-#define CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_REQUEST_MAX_LEN 64
+#define CTLV_ATTESTATION_OP_EVIDENCE_ACCEPT_REQUEST_MAX_LEN 280
 
 static inline int ctlv_attestation_evidence_accept_request_new(struct ctlv_msg **request)
 {

@@ -373,6 +373,11 @@ static inline int ctlv_attestation_evidence_options_start(struct ctlv_msg *msg)
 	return ctlv_nest_start(msg, CTLV_ATTESTATION_ATTR_EVIDENCE_OPTIONS);
 }
 
+static inline int ctlv_attestation_evidence_accept_object_start(struct ctlv_msg *msg)
+{
+	return ctlv_nest_start(msg, CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT);
+}
+
 static inline int ctlv_attestation_mr_id_put(struct ctlv_msg *msg, __u64 value)
 {
 	return ctlv_put_u64(msg, CTLV_ATTESTATION_ATTR_MR_ID, value);

@@ -913,6 +918,17 @@ ctlv_attestation_evidence_options_get(const struct ctlv_attr *nest)
 	return ctlv_attr_find(nest, CTLV_ATTESTATION_ATTR_EVIDENCE_OPTIONS);
 }
 
+static inline bool ctlv_attestation_evidence_accept_object_present(const struct ctlv_attr *nest)
+{
+	return ctlv_attr_find(nest, CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT);
+}
+
+static inline const struct ctlv_attr *
+ctlv_attestation_evidence_accept_object_get(const struct ctlv_attr *nest)
+{
+	return ctlv_attr_find(nest, CTLV_ATTESTATION_ATTR_EVIDENCE_ACCEPT_OBJECT);
+}
+
 static inline bool ctlv_attestation_mr_id_present(const struct ctlv_attr *nest)
 {
 	return ctlv_attr_find(nest, CTLV_ATTESTATION_ATTR_MR_ID);

index f0238c4c4cf2..50aa3cb84ddd 100644
@@ -350,13 +350,14 @@ static int attestation_evidence_request_decode(struct attestation *att, struct c
 					       struct ctlv_cursor *options)
 {
 	const struct attestation_evidence_caps *caps = att->provider->evidence_caps;
-	u32 challenge_length, guid_length;
+	u32 challenge_length = 0, guid_length;
 	const void *guid;
 	bool service;
 	int ret;
 
-	decoded->challenge =
-		ctlv_attestation_evidence_get_evidence_challenge_get(request, &challenge_length);
+	if (ctlv_attestation_evidence_get_evidence_challenge_present(request))
+		decoded->challenge = ctlv_attestation_evidence_get_evidence_challenge_get(
+			request, &challenge_length);
 	decoded->challenge_length = challenge_length;
 	if (challenge_length < caps->min_challenge_length ||
 	    challenge_length > caps->max_challenge_length)

index a858a84da135..0bd4bc76b718 100644
@@ -49,9 +49,9 @@ static const struct ctlv_stub_schema device_get_reply_stub_schemas[] = {
 };
 
 static const struct ctlv_node_schema evidence_get_request_node_schemas[] = {
-	CTLV_NODE_SCHEMA_ROOT(1, 9, 2),
-	CTLV_NODE_SCHEMA_BINARY(CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE, 1, 0, 4096),
+	CTLV_NODE_SCHEMA_ROOT(1, 9, 1),
 	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT, 16, 10, 6, 4),
+	CTLV_NODE_SCHEMA_BINARY(CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE, 1, 0, 4096),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 1, 0, U32_MAX),
 	CTLV_NODE_SCHEMA_NEST(CTLV_ATTESTATION_ATTR_EVIDENCE_SELECTION, 256, 16, 2, 2),
 	CTLV_NODE_SCHEMA_UINT(CTLV_ATTESTATION_ATTR_EVIDENCE_PRIVLEVEL, 1, 0, U32_MAX),

index 95cb6a083633..bd55158d8819 100644
@@ -81,15 +81,15 @@ CTLV_OP_DISABLE(ctlv_attestation_devsec_state_get, CTLV_ATTESTATION_OP_DEVSEC_ST
 CTLV_OP_PROVIDE(ctlv_attestation_mr_log_get, CTLV_ATTESTATION_OP_MR_LOG_GET)
 
 /* Reading a validated message. A blob has a resolver instead of a getter. */
+CTLV_IN_REF(ctlv_attestation_evidence_get_evidence_object, &ctlv_attestation_op_schemas[1].request,
+	    CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT, 0, 0, CTLV_SCHEMA_NEST)
+#define ctlv_attestation_evidence_get_evidence_object_for_each(_attr, _nest) \
+	CTLV_IN_FOR_EACH(ctlv_attestation_evidence_get_evidence_object, _attr, _nest)
 CTLV_IN_REF(ctlv_attestation_evidence_get_evidence_challenge,
-	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE, 0, 0,
+	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE, 0, 1,
 	    CTLV_SCHEMA_BINARY)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_evidence_challenge)
 CTLV_IN_BINARY(ctlv_attestation_evidence_get_evidence_challenge)
-CTLV_IN_REF(ctlv_attestation_evidence_get_evidence_object, &ctlv_attestation_op_schemas[1].request,
-	    CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT, 0, 1, CTLV_SCHEMA_NEST)
-#define ctlv_attestation_evidence_get_evidence_object_for_each(_attr, _nest) \
-	CTLV_IN_FOR_EACH(ctlv_attestation_evidence_get_evidence_object, _attr, _nest)
 CTLV_IN_REF(ctlv_attestation_evidence_get_device_generation,
 	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_DEVICE_GENERATION, 0, 2,
 	    CTLV_SCHEMA_UINT)

@@ -125,32 +125,32 @@ CTLV_IN_REF(ctlv_attestation_evidence_get_evidence_options, &ctlv_attestation_op
 CTLV_IN_HAS(ctlv_attestation_evidence_get_evidence_options)
 CTLV_IN_NEST(ctlv_attestation_evidence_get_evidence_options)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_blob_class,
-	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_CLASS, 2,
+	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_CLASS, 1,
 	    0, CTLV_SCHEMA_ENUM)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_blob_class)
 CTLV_IN_U64(ctlv_attestation_evidence_get_object_evidence_blob_class)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_format,
-	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_FORMAT, 2, 1,
+	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_FORMAT, 1, 1,
 	    CTLV_SCHEMA_STRING)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_format)
 CTLV_IN_STRING(ctlv_attestation_evidence_get_object_evidence_format)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_representation,
 	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_REPRESENTATION,
-	    2, 2, CTLV_SCHEMA_ENUM)
+	    1, 2, CTLV_SCHEMA_ENUM)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_representation)
 CTLV_IN_U64(ctlv_attestation_evidence_get_object_evidence_representation)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_data,
-	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_DATA, 2, 3,
+	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_DATA, 1, 3,
 	    CTLV_SCHEMA_BLOB)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_data)
 CTLV_IN_BLOB(ctlv_attestation_evidence_get_object_evidence_data)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_blob_instance,
 	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_BLOB_INSTANCE,
-	    2, 4, CTLV_SCHEMA_UINT)
+	    1, 4, CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_blob_instance)
 CTLV_IN_U64(ctlv_attestation_evidence_get_object_evidence_blob_instance)
 CTLV_IN_REF(ctlv_attestation_evidence_get_object_evidence_hash_algo,
-	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_HASH_ALGO, 2, 5,
+	    &ctlv_attestation_op_schemas[1].request, CTLV_ATTESTATION_ATTR_EVIDENCE_HASH_ALGO, 1, 5,
 	    CTLV_SCHEMA_UINT)
 CTLV_IN_HAS(ctlv_attestation_evidence_get_object_evidence_hash_algo)
 CTLV_IN_U64(ctlv_attestation_evidence_get_object_evidence_hash_algo)

index bd831b0ef14f..40be7fd0c492 100644
@@ -374,15 +374,13 @@ TEST_F(attestation, extension_record_log_and_event)
 static int evidence_get(struct ctlv_dev *dev, void *output, size_t output_length,
 			struct ctlv_reply **reply, struct ctlv_error *error)
 {
-	static const unsigned char challenge[] = "freshness";
 	struct ctlv_msg *request;
 	int ret;
 
 	ret = ctlv_attestation_evidence_get_request_new(&request);
 	if (ret)
 		return ret;
-	ctlv_attestation_evidence_challenge_put(
-		request, challenge, sizeof(challenge) - 1);
+	/* Providers with a zero minimum accept an omitted challenge. */
 	ctlv_attestation_evidence_object_start(request);
 	ctlv_attestation_evidence_blob_class_put(
 		request, CTLV_ATTESTATION_EVIDENCE_BLOB_CLASS_PRIMARY);

index 795cf514c761..89b7db4df55b 100644
@@ -279,14 +279,6 @@ static const struct ctlv_node_schema evidence_get_request_selection_attr_node_sc
 
 /* root, attrs */
 static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] = {
-	{
-		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
-		.kind = CTLV_SCHEMA_BINARY,
-		.max_occurrences = 1,
-		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
-		.min_length = 0,
-		.max_length = 4096,
-	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT,
 		.kind = CTLV_SCHEMA_NEST,

@@ -300,6 +292,14 @@ static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] =
 
 /* root, optional attrs */
 static const struct ctlv_node_schema evidence_get_request_optional_attr_node_schemas[] = {
+	{
+		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
+		.kind = CTLV_SCHEMA_BINARY,
+		.max_occurrences = 1,
+		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
+		.min_length = 0,
+		.max_length = 4096,
+	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_DEVICE_GENERATION,
 		.kind = CTLV_SCHEMA_UINT,

@@ -359,9 +359,9 @@ static const struct ctlv_node_schema evidence_get_request_node_schema = {
 	.kind = CTLV_SCHEMA_NEST,
 	.max_occurrences = 1,
 	.attrs = evidence_get_request_attr_node_schemas,
-	.attrs_count = 2,
+	.attrs_count = 1,
 	.optional_attrs = evidence_get_request_optional_attr_node_schemas,
-	.optional_attrs_count = 7,
+	.optional_attrs_count = 8,
 };
 
 /* root, attrs */

index 787edd7d8ce4..cdf54af49a81 100644
@@ -295,14 +295,6 @@ static const struct ctlv_node_schema evidence_get_request_selection_attr_node_sc
 
 /* root, attrs */
 static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] = {
-	{
-		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
-		.kind = CTLV_SCHEMA_BINARY,
-		.max_occurrences = 1,
-		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
-		.min_length = 0,
-		.max_length = 4096,
-	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT,
 		.kind = CTLV_SCHEMA_NEST,

@@ -316,6 +308,14 @@ static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] =
 
 /* root, optional attrs */
 static const struct ctlv_node_schema evidence_get_request_optional_attr_node_schemas[] = {
+	{
+		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
+		.kind = CTLV_SCHEMA_BINARY,
+		.max_occurrences = 1,
+		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
+		.min_length = 0,
+		.max_length = 4096,
+	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_DEVICE_GENERATION,
 		.kind = CTLV_SCHEMA_UINT,

@@ -375,9 +375,9 @@ static const struct ctlv_node_schema evidence_get_request_node_schema = {
 	.kind = CTLV_SCHEMA_NEST,
 	.max_occurrences = 1,
 	.attrs = evidence_get_request_attr_node_schemas,
-	.attrs_count = 2,
+	.attrs_count = 1,
 	.optional_attrs = evidence_get_request_optional_attr_node_schemas,
-	.optional_attrs_count = 7,
+	.optional_attrs_count = 8,
 };
 
 /* root, attrs */

index b278511f5776..077f8c7fbc81 100644
@@ -265,14 +265,6 @@ static const struct ctlv_node_schema evidence_get_request_selection_attr_node_sc
 
 /* root, attrs */
 static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] = {
-	{
-		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
-		.kind = CTLV_SCHEMA_BINARY,
-		.max_occurrences = 1,
-		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
-		.min_length = 0,
-		.max_length = 4096,
-	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_OBJECT,
 		.kind = CTLV_SCHEMA_NEST,

@@ -286,6 +278,14 @@ static const struct ctlv_node_schema evidence_get_request_attr_node_schemas[] =
 
 /* root, optional attrs */
 static const struct ctlv_node_schema evidence_get_request_optional_attr_node_schemas[] = {
+	{
+		.attr_id = CTLV_ATTESTATION_ATTR_EVIDENCE_CHALLENGE,
+		.kind = CTLV_SCHEMA_BINARY,
+		.max_occurrences = 1,
+		.present = CTLV_NODE_SCHEMA_HAS_MIN_LENGTH | CTLV_NODE_SCHEMA_HAS_MAX_LENGTH,
+		.min_length = 0,
+		.max_length = 4096,
+	},
 	{
 		.attr_id = CTLV_ATTESTATION_ATTR_DEVICE_GENERATION,
 		.kind = CTLV_SCHEMA_UINT,

@@ -345,9 +345,9 @@ static const struct ctlv_node_schema evidence_get_request_node_schema = {
 	.kind = CTLV_SCHEMA_NEST,
 	.max_occurrences = 1,
 	.attrs = evidence_get_request_attr_node_schemas,
-	.attrs_count = 2,
+	.attrs_count = 1,
 	.optional_attrs = evidence_get_request_optional_attr_node_schemas,
-	.optional_attrs_count = 7,
+	.optional_attrs_count = 8,
 };
 
 /* root, attrs */

index a06315af2021..1a370a529f50 100644
@@ -165,8 +165,9 @@ static int tdx_evidence_get(struct ctlv_dev *dev, const char *format,
 	ret = ctlv_attestation_evidence_get_request_new(&request);
 	if (ret)
 		return ret;
-	ctlv_attestation_evidence_challenge_put(request, challenge,
-						challenge_length);
+	if (challenge)
+		ctlv_attestation_evidence_challenge_put(request, challenge,
+							challenge_length);
 	ctlv_attestation_evidence_object_start(request);
 	ctlv_attestation_evidence_blob_class_put(request,
 						 CTLV_ATTESTATION_EVIDENCE_BLOB_CLASS_PRIMARY);

@@ -244,6 +245,10 @@ TEST_F(tdx_attestation, common_validation_precedes_native_calls)
 	struct ctlv_reply *reply;
 	struct ctlv_msg *request;
 
+	EXPECT_EQ(-EINVAL,
+		  tdx_evidence_get(self->dev, "tdx-tdreport-1.0", NULL, 0,
+				   report.bytes, sizeof(report.bytes), &reply,
+				   &self->error));
 	EXPECT_EQ(-EINVAL,
 		  tdx_evidence_get(self->dev, "tdx-tdreport-1.0", challenge,
 				   sizeof(challenge) - 1, report.bytes,

111 lines not on this page · raw message

100 lines not on this page · raw message

74 lines not on this page · raw message

index 19c478660429..bad143ec85fd 100644
@@ -15,6 +15,7 @@ enum _ctlv_family {
 	CTLV_FAMILY_TEST,
 	CTLV_FAMILY_TEST_CHILD,
 	CTLV_FAMILY_ATTESTATION_SIM,
+	CTLV_FAMILY_ATTESTATION_PCI,
 };
 
 #endif /* _UAPI_LINUX_CTLV_FAMILIES_GEN_H */

1,697 lines not on this page · raw message

230 lines not on this page · raw message

index 914f29693aee..e35c45bc715d 100644
@@ -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;

53 lines not on this page · raw message

index 6d089714900c..e905ed9de9b5 100644
@@ -307,6 +307,7 @@ static int dsm_connect(struct pci_dev *pdev)
 
 	tc_mask = streams_setup(dev_data->ide, ids);
 
+	dev_data->cert_slot = pdev->tsm->evidence.slot;
 	ret = sev_tio_dev_connect(dev_data, tc_mask, ids, dev_data->cert_slot);
 	ret = sev_tio_spdm_cmd(dsm, ret);
 	if (ret)

525 lines not on this page · raw message

725 lines not on this page · raw message

274 lines not on this page · raw message

new file mode 100644
index 000000000000..613267a84b8f
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _PCI_TSM_INTERNAL_H
+#define _PCI_TSM_INTERNAL_H
+
+#include <linux/types.h>
+
+struct pci_dev;
+struct list_head;
+struct tsm_dev;
+
+/* All helpers require pci_tsm_rwsem held for write. */
+bool pci_tsm_can_lock(struct tsm_dev *tsm_dev);
+void pci_tsm_attestation_update(struct pci_dev *pdev);
+int pci_tsm_attestation_add(struct pci_dev *pdev);
+void pci_tsm_attestation_remove(struct pci_dev *pdev, struct list_head *retired);
+int pci_tsm_evidence_accept(struct pci_dev *pdev, unsigned int slot);
+int pci_tsm_disconnect(struct pci_dev *pdev);
+int pci_tsm_lock(struct pci_dev *pdev, struct tsm_dev *tsm_dev);
+int pci_tsm_unlock(struct pci_dev *pdev);
+int pci_tsm_accept(struct pci_dev *pdev);
+void pci_tsm_attestation_notify_state_change(struct pci_dev *pdev);
+
+/* Call after dropping PCI and device locks to drain retired CTLV requests. */
+void pci_tsm_attestation_destroy(struct list_head *retired);
+
+#endif

43 lines not on this page · raw message

deleted file mode 100644
index 34f3fb6ba2b7..000000000000
@@ -1,23 +0,0 @@
-/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */
-/* Do not edit directly, auto-generated from: */
-/*	Documentation/netlink/specs/pci-tsm.yaml */
-/* YNL-GEN kernel header */
-/* To regenerate run: tools/net/ynl/ynl-regen.sh */
-
-#ifndef _LINUX_PCI_TSM_GEN_H
-#define _LINUX_PCI_TSM_GEN_H
-
-#include <net/netlink.h>
-#include <net/genetlink.h>
-
-#include <uapi/linux/pci-tsm-netlink.h>
-
-int pci_tsm_nl_evidence_read_pre(struct netlink_callback *cb);
-int pci_tsm_nl_evidence_read_post(struct netlink_callback *cb);
-
-int pci_tsm_nl_evidence_read_dumpit(struct sk_buff *skb,
-				    struct netlink_callback *cb);
-
-extern struct genl_family pci_tsm_nl_family;
-
-#endif /* _LINUX_PCI_TSM_GEN_H */

index 50a21317c941..f50f3e660bbc 100644
@@ -340,8 +340,7 @@ static int cca_collect_dev_evidence(struct pci_dev *pdev, struct cca_guest_dsc *
 	down_write(&evidence->lock);
 	evidence->generation = dev_info->meas_seq;
 
-	/* we default to slot 0 in pdev_create */
-	obj = &evidence->obj[PCI_TSM_EVIDENCE_TYPE_CERT0];
+	obj = &evidence->obj[PCI_TSM_EVIDENCE_TYPE_CERT0 + evidence->slot];
 	WARN_ON(obj->data);
 	obj->data = certificate;
 	obj->len = certificate_size;

@@ -367,6 +366,11 @@ static int cca_collect_dev_evidence(struct pci_dev *pdev, struct cca_guest_dsc *
 	memcpy(dsc->dev_info.vca_digest, dev_info->protocol_data_digest, SHA512_DIGEST_SIZE);
 	memcpy(dsc->dev_info.meas_digest, dev_info->meas_digest, SHA512_DIGEST_SIZE);
 	memcpy(dsc->dev_info.report_digest, dev_info->report_digest, SHA512_DIGEST_SIZE);
+	evidence->obj[PCI_TSM_EVIDENCE_TYPE_CERT0 + evidence->slot].digest =
+		dsc->dev_info.cert_digest;
+	evidence->obj[PCI_TSM_EVIDENCE_TYPE_VCA].digest = dsc->dev_info.vca_digest;
+	evidence->obj[PCI_TSM_EVIDENCE_TYPE_MEASUREMENTS].digest = dsc->dev_info.meas_digest;
+	evidence->obj[PCI_TSM_EVIDENCE_TYPE_REPORT].digest = dsc->dev_info.report_digest;
 	up_write(&evidence->lock);
 
 	kfree(dev_info);

@@ -416,6 +420,11 @@ static struct pci_tsm *cca_tsm_lock(struct tsm_dev *tsm_dev, struct pci_dev *pde
 		goto free_dev_info;
 	}
 
+	if (dev_info->id_index) {
+		ret = -EOPNOTSUPP;
+		goto free_dev_info;
+	}
+
 	/* Collect the lock sequence number. */
 	cca_dsc->dev_info.lock_seq = dev_info->lock_seq;
 

@@ -450,7 +459,7 @@ static struct pci_tsm *cca_tsm_lock(struct tsm_dev *tsm_dev, struct pci_dev *pde
 	return ERR_PTR(ret);
 }
 
-static void cca_tsm_unlock(struct pci_tsm *tsm)
+static int cca_tsm_unlock(struct pci_tsm *tsm)
 {
 	long ret;
 	struct pci_dev *pdev = tsm->pdev;

@@ -460,20 +469,22 @@ static void cca_tsm_unlock(struct pci_tsm *tsm)
 	ret = cca_unmap_evidence_report_range(tsm->pdev);
 	if (ret) {
 		pci_err(tsm->pdev, "failed to invalidate the interface report\n");
-		goto err_out;
+		return ret;
 	}
 
-	cca_device_unlock(tsm->pdev);
+	ret = cca_device_unlock(tsm->pdev);
+	if (ret)
+		return ret;
+
 	if (cca_dsc->pci.mmio)
 		pci_tsm_mmio_teardown(cca_dsc->pci.mmio);
 
-err_out:
-	/*
-	 * No error handling from this function. Leave the device locked
-	 */
 	if (cca_dsc->pci.mmio)
 		pci_tsm_mmio_free(tsm->pdev, cca_dsc->pci.mmio);
+	for (int i = 0; i <= PCI_TSM_EVIDENCE_TYPE_MAX; i++)
+		kvfree(tsm->evidence.obj[i].data);
 	kfree(cca_dsc);
+	return 0;
 }
 
 static int __cca_tsm_accept(struct pci_dev *pdev, unsigned long lock_seq)

@@ -496,6 +507,11 @@ static int cca_tsm_accept(struct pci_dev *pdev)
 }
 
 static struct pci_tsm_ops cca_devsec_pci_ops = {
+	.owner = THIS_MODULE,
+	.evidence_types = BIT(PCI_TSM_EVIDENCE_TYPE_CERT0) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_VCA) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_MEASUREMENTS) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_REPORT),
 	.lock = cca_tsm_lock,
 	.unlock = cca_tsm_unlock,
 	.accept	 = cca_tsm_accept,

index b83b0b654ac3..f7a3c24817bb 100644
@@ -268,28 +268,26 @@ int cca_device_accept(struct pci_dev *pdev, unsigned long lock_seq)
 		goto err_mmio_setup;
 	}
 
+	/* Keep partial mappings reachable until a successful UNLOCK. */
+	dsc->pci.mmio = tsm_mmio;
 	ret = cca_map_evidence_report_range(pdev, tsm_mmio);
 	if (ret) {
 		pci_err(pdev, "failed to validate the interface report\n");
-		goto err_evidence_report_map;
+		return ret;
 	}
 
 	ret = rhi_vdev_set_tdi_state(pdev, RHI_DA_TDI_CONFIG_RUN);
 	if (ret) {
 		pci_err(pdev, "failed to switch the device (%u) to RUN state\n", ret);
-		goto err_tdi_config_run;
+		return ret;
 	}
 
-	if (rsi_vdev_enable_dma(vdev_id, &dsc->dev_info))
+	if (rsi_vdev_enable_dma(vdev_id, &dsc->dev_info)) {
 		pci_err(pdev, "failed to enable DMA from the device\n");
-
-	dsc->pci.mmio = no_free_ptr(tsm_mmio);
+		return -EIO;
+	}
 	return 0;
 
-err_tdi_config_run:
-	cca_unmap_evidence_report_range(pdev);
-err_evidence_report_map:
-	pci_tsm_mmio_teardown(tsm_mmio);
 err_mmio_setup:
 	pci_tsm_mmio_free(pdev, tsm_mmio);
 	return ret;

175 lines not on this page · raw message

index d31a8d107b1e..39541d217fac 100644
@@ -580,6 +580,8 @@ struct pci_dev {
 #endif
 #ifdef CONFIG_PCI_TSM
 	struct pci_tsm *tsm;		/* TSM operation state */
+	struct pci_tsm_attestation *tsm_attestation; /* Connected/locked CTLV instance */
+	bool tsm_attestation_removing; /* CTLV teardown is draining requests */
 #endif
 	u16		acs_cap;	/* ACS Capability offset */
 	u16		acs_capabilities; /* ACS Capabilities */

101 lines not on this page · raw message

index 5dc4152e8b99..641266ca0b7f 100644
@@ -5,7 +5,6 @@
 #include <linux/pci.h>
 #include <linux/pci-tsm.h>
 #include <linux/vmalloc.h>
-#include <uapi/linux/pci-tsm-netlink.h>
 
 #include "devsec.h"
 

index 864ddf592db4..61cf6c16e1b5 100644
@@ -231,6 +231,7 @@ static void devsec_link_tsm_disconnect(struct pci_dev *pdev)
 }
 
 static struct pci_tsm_ops devsec_link_pci_ops = {
+	.evidence_types = BIT(PCI_TSM_EVIDENCE_TYPE_CERT0),
 	.probe = devsec_link_tsm_pci_probe,
 	.remove = devsec_link_tsm_pci_remove,
 	.connect = devsec_link_tsm_connect,

index 7d480a306e13..6ff88ca83906 100644
@@ -2,6 +2,7 @@
 /* Copyright (C) 2024 - 2026 Intel Corporation */
 
 #define dev_fmt(fmt) "devsec: " fmt
+#include <crypto/hash_info.h>
 #include <linux/device/faux.h>
 #include <linux/pci-tsm.h>
 #include <linux/module.h>

@@ -10,6 +11,13 @@
 #include <linux/tsm.h>
 #include "devsec.h"
 
+static bool fail_accept;
+module_param(fail_accept, bool, 0600);
+MODULE_PARM_DESC(fail_accept, "Fail native ACCEPT for recovery testing");
+static bool fail_unlock;
+module_param(fail_unlock, bool, 0600);
+MODULE_PARM_DESC(fail_unlock, "Fail native UNLOCK while retaining its context");
+
 struct devsec_dev_data {
 	struct pci_tsm_devsec pci;
 };

@@ -32,17 +40,30 @@ static struct pci_tsm *devsec_tsm_lock(struct tsm_dev *tsm_dev, struct pci_dev *
 	if (rc)
 		return ERR_PTR(rc);
 
+	devsec_evidence_busy();
+	pci_tsm_init_evidence(&devsec_data->pci.base_tsm.evidence, 0, HASH_ALGO_SHA384);
+	devsec_init_evidence(&devsec_data->pci.base_tsm.evidence);
+	/* The sample uses the same synthetic payload for all guest reports. */
+	devsec_data->pci.base_tsm.evidence.obj[PCI_TSM_EVIDENCE_TYPE_VCA] =
+		devsec_data->pci.base_tsm.evidence.obj[PCI_TSM_EVIDENCE_TYPE_MEASUREMENTS];
+	devsec_data->pci.base_tsm.evidence.obj[PCI_TSM_EVIDENCE_TYPE_REPORT] =
+		devsec_data->pci.base_tsm.evidence.obj[PCI_TSM_EVIDENCE_TYPE_MEASUREMENTS];
 	return &no_free_ptr(devsec_data)->pci.base_tsm;
 }
 
-static void devsec_tsm_unlock(struct pci_tsm *tsm)
+static int devsec_tsm_unlock(struct pci_tsm *tsm)
 {
 	struct devsec_dev_data *devsec_data = to_devsec_data(tsm);
 	struct pci_tsm_devsec *devsec_tsm = to_pci_tsm_devsec(tsm);
 
-	pci_tsm_mmio_teardown(devsec_tsm->mmio);
+	if (READ_ONCE(fail_unlock))
+		return -EIO;
+	if (devsec_tsm->mmio)
+		pci_tsm_mmio_teardown(devsec_tsm->mmio);
 	kfree(devsec_tsm->mmio);
+	devsec_evidence_idle();
 	kfree(devsec_data);
+	return 0;
 }
 
 static int devsec_tsm_accept(struct pci_dev *pdev)

@@ -54,6 +75,8 @@ static int devsec_tsm_accept(struct pci_dev *pdev)
 		kzalloc(struct_size(mmio, mmio, PCI_NUM_RESOURCES), GFP_KERNEL);
 	if (!mmio)
 		return -ENOMEM;
+	if (READ_ONCE(fail_accept))
+		return -EIO;
 
 	/*
 	 * Typically this range request would come from the TDISP Interface

@@ -78,6 +101,11 @@ static int devsec_tsm_accept(struct pci_dev *pdev)
 }
 
 static struct pci_tsm_ops devsec_pci_ops = {
+	.owner = THIS_MODULE,
+	.evidence_types = BIT(PCI_TSM_EVIDENCE_TYPE_CERT0) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_VCA) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_MEASUREMENTS) |
+			  BIT(PCI_TSM_EVIDENCE_TYPE_REPORT),
 	.lock = devsec_tsm_lock,
 	.unlock = devsec_tsm_unlock,
 	.accept = devsec_tsm_accept,