[PATCH 14/15] perf/core: Add event_caps dependency flags

[Dapeng Mi]

Add two new event capability flags:
- PERF_EV_CAP_RELIED_ON: An event that other group events rely on. Must
  not be set on a group leader.
- PERF_EV_CAP_RELIANT: An event that relies on a group event carrying
  PERF_EV_CAP_RELIED_ON. Must not be combined with PERF_EV_CAP_RELIED_ON.
  If the dependency is on the group leader, use PERF_EV_CAP_SIBLING
  instead of PERF_EV_CAP_RELIANT.

When an event with PERF_EV_CAP_RELIED_ON is detached from the group, all
events in the group carrying PERF_EV_CAP_RELIANT can no longer function
and must be transitioned to the ERROR state.

Signed-off-by: Dapeng Mi <dapeng1.mi@xxxxxxxxxxxxxxx>
---
 include/linux/perf_event.h |  8 ++++++
 kernel/events/core.c       | 52 +++++++++++++++++++++++++++++++++-----
 2 files changed, 53 insertions(+), 7 deletions(-)

diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 7797ce207555..3031fe8dab37 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -706,11 +706,19 @@ typedef void (*perf_overflow_handler_t)(struct perf_event *,
  * group it is scheduled out and moved into an unrecoverable ERROR state.
  * PERF_EV_CAP_READ_SCOPE: A CPU event that can be read from any CPU of the
  * PMU scope where it is active.
+ * PERF_EV_CAP_RELIED_ON: An event on which other group members depend.
+ * This flag must not be set on a group leader.
+ * PERF_EV_CAP_RELIANT: A member that depends on another group event carrying
+ * PERF_EV_CAP_RELIED_ON. It must not be combined with PERF_EV_CAP_RELIED_ON
+ * and must not be set on a group leader. If the dependency is on the group
+ * leader, use PERF_EV_CAP_SIBLING instead.
  */
 #define PERF_EV_CAP_SOFTWARE		BIT(0)
 #define PERF_EV_CAP_READ_ACTIVE_PKG	BIT(1)
 #define PERF_EV_CAP_SIBLING		BIT(2)
 #define PERF_EV_CAP_READ_SCOPE		BIT(3)
+#define PERF_EV_CAP_RELIED_ON		BIT(4)
+#define PERF_EV_CAP_RELIANT		BIT(5)
 
 #define SWEVENT_HLIST_BITS		8
 #define SWEVENT_HLIST_SIZE		(1 << SWEVENT_HLIST_BITS)
diff --git a/kernel/events/core.c b/kernel/events/core.c
index de05df65ab3d..55db0ad8b93a 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -2349,13 +2349,12 @@ static void perf_promote_sibling_to_leader(struct perf_event *sibling,
 					   int group_caps)
 {
 	/*
-	 * Events that have PERF_EV_CAP_SIBLING require being part of
-	 * a group and cannot exist on their own, schedule them out
-	 * and move them into the ERROR state. Also see
-	 * _perf_event_enable(), it will not be able to recover this
-	 * ERROR state.
+	 * Events with PERF_EV_CAP_SIBLING or PERF_EV_CAP_RELIANT
+	 * must stay in a group or depend on another event in the
+	 * group; otherwise schedule them out and move them to ERROR.
+	 * _perf_event_enable() cannot recover from this state.
 	 */
-	if (sibling->event_caps & PERF_EV_CAP_SIBLING)
+	if (sibling->event_caps & (PERF_EV_CAP_SIBLING | PERF_EV_CAP_RELIANT))
 		__event_disable(sibling, ctx, PERF_EVENT_STATE_ERROR);
 
 	sibling->group_leader = sibling;
@@ -2371,6 +2370,43 @@ static void perf_promote_sibling_to_leader(struct perf_event *sibling,
 	perf_event__header_size(sibling);
 }
 
+static void perf_group_disable_reliants(struct perf_event *event)
+{
+	struct perf_event *leader = event->group_leader;
+	struct perf_event *sibling, *tmp;
+	struct perf_event_context *ctx = event->ctx;
+	u32 mask = PERF_EV_CAP_RELIED_ON | PERF_EV_CAP_RELIANT;
+
+	if (!(event->event_caps & PERF_EV_CAP_RELIED_ON))
+		return;
+
+	/* Group leader should not carry PERF_EV_CAP_RELIED_ON. */
+	WARN_ON_ONCE(leader->event_caps & PERF_EV_CAP_RELIED_ON);
+	/* Group leader should not carry PERF_EV_CAP_RELIANT. */
+	WARN_ON_ONCE(leader->event_caps & PERF_EV_CAP_RELIANT);
+
+	/*
+	 * Disable all siblings that rely on this event. Without it,
+	 * they cannot function and would otherwise fall into ERROR state.
+	 */
+	list_for_each_entry_safe(sibling, tmp, &leader->sibling_list, sibling_list) {
+		if (!(sibling->event_caps & PERF_EV_CAP_RELIANT))
+			continue;
+
+		/*
+		 * An event must not set both PERF_EV_CAP_RELIED_ON and
+		 * PERF_EV_CAP_RELIANT simultaneously.
+		 */
+		if (WARN_ON_ONCE((sibling->event_caps & mask) == mask))
+			continue;
+
+		list_del_init(&sibling->sibling_list);
+		leader->nr_siblings--;
+		leader->group_generation++;
+		perf_promote_sibling_to_leader(sibling, ctx, leader->group_caps);
+	}
+}
+
 static void perf_group_detach(struct perf_event *event)
 {
 	struct perf_event *leader = event->group_leader;
@@ -2393,6 +2429,7 @@ static void perf_group_detach(struct perf_event *event)
 	 * If this is a sibling, remove it from its group.
 	 */
 	if (leader != event) {
+		perf_group_disable_reliants(event);
 		list_del_init(&event->sibling_list);
 		leader->nr_siblings--;
 		leader->group_generation++;
@@ -3305,7 +3342,8 @@ static void _perf_event_enable(struct perf_event *event)
 		/*
 		 * Detached SIBLING events cannot leave ERROR state.
 		 */
-		if (event->event_caps & PERF_EV_CAP_SIBLING &&
+		if (event->event_caps &
+		    (PERF_EV_CAP_SIBLING | PERF_EV_CAP_RELIANT) &&
 		    event->group_leader == event)
 			goto out;
 
-- 
2.34.1