shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-06 10:58:48 +09:00
Code Issues Packages Projects Releases Wiki Activity

Revert "perf: Disallow mis-matched inherited group reads"

Browse Source 
This reverts commit f6952655a6 which is
commit 32671e3799 upstream.

It breaks the android ABI and if this is needed in the future, can be
brought back in an abi-safe way.

Bug: 161946584
Change-Id: Ia00890aeeef6153c7f3462a2a2189149734ac28a
Signed-off-by: Greg Kroah-Hartman <gregkh@google.com>
This commit is contained in:
Greg Kroah-Hartman
2023-10-26 10:28:09 +00:00
parent 4933ddb051
commit 63eafbb6b3
2 changed files with 6 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/linux/perf_event.h
View File

@@ -694,7 +694,6 @@ struct perf_event {
/* The cumulative AND of all event_caps for events in this group. */ /* The cumulative AND of all event_caps for events in this group. */
int group_caps; int group_caps;
unsigned int group_generation;
struct perf_event *group_leader; struct perf_event *group_leader;
struct pmu *pmu; struct pmu *pmu;
void *pmu_private; void *pmu_private;

39
kernel/events/core.c
View File

@@ -1962,7 +1962,6 @@ static void perf_group_attach(struct perf_event *event)
list_add_tail(&event->sibling_list, &group_leader->sibling_list); list_add_tail(&event->sibling_list, &group_leader->sibling_list);
group_leader->nr_siblings++; group_leader->nr_siblings++;
group_leader->group_generation++;
perf_event__header_size(group_leader); perf_event__header_size(group_leader);
@@ -2157,7 +2156,6 @@ static void perf_group_detach(struct perf_event *event)
if (leader != event) { if (leader != event) {
list_del_init(&event->sibling_list); list_del_init(&event->sibling_list);
event->group_leader->nr_siblings--; event->group_leader->nr_siblings--;
event->group_leader->group_generation++;
goto out; goto out;
} }
@@ -5282,7 +5280,7 @@ static int __perf_read_group_add(struct perf_event *leader,
u64 read_format, u64 *values) u64 read_format, u64 *values)
{ {
struct perf_event_context *ctx = leader->ctx; struct perf_event_context *ctx = leader->ctx;
struct perf_event *sub, *parent; struct perf_event *sub;
unsigned long flags; unsigned long flags;
int n = 1; /* skip @nr */ int n = 1; /* skip @nr */
int ret; int ret;
@@ -5292,33 +5290,6 @@ static int __perf_read_group_add(struct perf_event *leader,
return ret; return ret;
raw_spin_lock_irqsave(&ctx->lock, flags); raw_spin_lock_irqsave(&ctx->lock, flags);
/*
* Verify the grouping between the parent and child (inherited)
* events is still in tact.
*
* Specifically:
* - leader->ctx->lock pins leader->sibling_list
* - parent->child_mutex pins parent->child_list
* - parent->ctx->mutex pins parent->sibling_list
*
* Because parent->ctx != leader->ctx (and child_list nests inside
* ctx->mutex), group destruction is not atomic between children, also
* see perf_event_release_kernel(). Additionally, parent can grow the
* group.
*
* Therefore it is possible to have parent and child groups in a
* different configuration and summing over such a beast makes no sense
* what so ever.
*
* Reject this.
*/
parent = leader->parent;
if (parent &&
(parent->group_generation != leader->group_generation ||
parent->nr_siblings != leader->nr_siblings)) {
ret = -ECHILD;
goto unlock;
}
/* /*
* Since we co-schedule groups, {enabled,running} times of siblings * Since we co-schedule groups, {enabled,running} times of siblings
@@ -5352,9 +5323,8 @@ static int __perf_read_group_add(struct perf_event *leader,
values[n++] = atomic64_read(&sub->lost_samples); values[n++] = atomic64_read(&sub->lost_samples);
} }
unlock:
raw_spin_unlock_irqrestore(&ctx->lock, flags); raw_spin_unlock_irqrestore(&ctx->lock, flags);
return ret; return 0;
} }
static int perf_read_group(struct perf_event *event, static int perf_read_group(struct perf_event *event,
@@ -5373,6 +5343,10 @@ static int perf_read_group(struct perf_event *event,
values[0] = 1 + leader->nr_siblings; values[0] = 1 + leader->nr_siblings;
/*
* By locking the child_mutex of the leader we effectively
* lock the child list of all siblings.. XXX explain how.
*/
mutex_lock(&leader->child_mutex); mutex_lock(&leader->child_mutex);
ret = __perf_read_group_add(leader, read_format, values); ret = __perf_read_group_add(leader, read_format, values);
@@ -13279,7 +13253,6 @@ static int inherit_group(struct perf_event *parent_event,
!perf_get_aux_event(child_ctr, leader)) !perf_get_aux_event(child_ctr, leader))
return -EINVAL; return -EINVAL;
} }
leader->group_generation = parent_event->group_generation;
return 0; return 0;
} }