mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 16:29:59 +00:00
![Ian Rogers](/assets/img/avatar_default.png)
The code required threads to be deleted before machine__exit was called or the threads would be leaked. This was error prone so move the delete_threads into machine__exit. Signed-off-by: Ian Rogers <irogers@google.com> Cc: Adrian Hunter <adrian.hunter@intel.com> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Ali Saidi <alisaidi@amazon.com> Cc: Andi Kleen <ak@linux.intel.com> Cc: Athira Rajeev <atrajeev@linux.vnet.ibm.com> Cc: Brian Robbins <brianrob@linux.microsoft.com> Cc: Changbin Du <changbin.du@huawei.com> Cc: Dmitrii Dolgov <9erthalion6@gmail.com> Cc: Fangrui Song <maskray@google.com> Cc: German Gomez <german.gomez@arm.com> Cc: Ingo Molnar <mingo@redhat.com> Cc: Ivan Babrou <ivan@cloudflare.com> Cc: James Clark <james.clark@arm.com> Cc: Jing Zhang <renyu.zj@linux.alibaba.com> Cc: Jiri Olsa <jolsa@kernel.org> Cc: John Garry <john.g.garry@oracle.com> Cc: K Prateek Nayak <kprateek.nayak@amd.com> Cc: Kan Liang <kan.liang@linux.intel.com> Cc: Leo Yan <leo.yan@linaro.org> Cc: Liam Howlett <liam.howlett@oracle.com> Cc: Mark Rutland <mark.rutland@arm.com> Cc: Miguel Ojeda <ojeda@kernel.org> Cc: Mike Leach <mike.leach@linaro.org> Cc: Namhyung Kim <namhyung@kernel.org> Cc: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Ravi Bangoria <ravi.bangoria@amd.com> Cc: Sean Christopherson <seanjc@google.com> Cc: Steinar H. Gunderson <sesse@google.com> Cc: Suzuki Poulouse <suzuki.poulose@arm.com> Cc: Wenyu Liu <liuwenyu7@huawei.com> Cc: Will Deacon <will@kernel.org> Cc: Yang Jihong <yangjihong1@huawei.com> Cc: Ye Xingchen <ye.xingchen@zte.com.cn> Cc: Yuan Can <yuancan@huawei.com> Cc: coresight@lists.linaro.org Cc: linux-arm-kernel@lists.infradead.org Link: https://lore.kernel.org/r/20230608232823.4027869-9-irogers@google.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
242 lines
4.8 KiB
C
242 lines
4.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <inttypes.h>
|
|
#include <unistd.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/types.h>
|
|
#include <sys/mman.h>
|
|
#include <pthread.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "debug.h"
|
|
#include "event.h"
|
|
#include "tests.h"
|
|
#include "machine.h"
|
|
#include "thread_map.h"
|
|
#include "map.h"
|
|
#include "symbol.h"
|
|
#include "util/synthetic-events.h"
|
|
#include "thread.h"
|
|
#include <internal/lib.h> // page_size
|
|
|
|
#define THREADS 4
|
|
|
|
static int go_away;
|
|
|
|
struct thread_data {
|
|
pthread_t pt;
|
|
pid_t tid;
|
|
void *map;
|
|
int ready[2];
|
|
};
|
|
|
|
static struct thread_data threads[THREADS];
|
|
|
|
static int thread_init(struct thread_data *td)
|
|
{
|
|
void *map;
|
|
|
|
map = mmap(NULL, page_size,
|
|
PROT_READ|PROT_WRITE|PROT_EXEC,
|
|
MAP_SHARED|MAP_ANONYMOUS, -1, 0);
|
|
|
|
if (map == MAP_FAILED) {
|
|
perror("mmap failed");
|
|
return -1;
|
|
}
|
|
|
|
td->map = map;
|
|
td->tid = syscall(SYS_gettid);
|
|
|
|
pr_debug("tid = %d, map = %p\n", td->tid, map);
|
|
return 0;
|
|
}
|
|
|
|
static void *thread_fn(void *arg)
|
|
{
|
|
struct thread_data *td = arg;
|
|
ssize_t ret;
|
|
int go = 0;
|
|
|
|
if (thread_init(td))
|
|
return NULL;
|
|
|
|
/* Signal thread_create thread is initialized. */
|
|
ret = write(td->ready[1], &go, sizeof(int));
|
|
if (ret != sizeof(int)) {
|
|
pr_err("failed to notify\n");
|
|
return NULL;
|
|
}
|
|
|
|
while (!go_away) {
|
|
/* Waiting for main thread to kill us. */
|
|
usleep(100);
|
|
}
|
|
|
|
munmap(td->map, page_size);
|
|
return NULL;
|
|
}
|
|
|
|
static int thread_create(int i)
|
|
{
|
|
struct thread_data *td = &threads[i];
|
|
int err, go;
|
|
|
|
if (pipe(td->ready))
|
|
return -1;
|
|
|
|
err = pthread_create(&td->pt, NULL, thread_fn, td);
|
|
if (!err) {
|
|
/* Wait for thread initialization. */
|
|
ssize_t ret = read(td->ready[0], &go, sizeof(int));
|
|
err = ret != sizeof(int);
|
|
}
|
|
|
|
close(td->ready[0]);
|
|
close(td->ready[1]);
|
|
return err;
|
|
}
|
|
|
|
static int threads_create(void)
|
|
{
|
|
struct thread_data *td0 = &threads[0];
|
|
int i, err = 0;
|
|
|
|
go_away = 0;
|
|
|
|
/* 0 is main thread */
|
|
if (thread_init(td0))
|
|
return -1;
|
|
|
|
for (i = 1; !err && i < THREADS; i++)
|
|
err = thread_create(i);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int threads_destroy(void)
|
|
{
|
|
struct thread_data *td0 = &threads[0];
|
|
int i, err = 0;
|
|
|
|
/* cleanup the main thread */
|
|
munmap(td0->map, page_size);
|
|
|
|
go_away = 1;
|
|
|
|
for (i = 1; !err && i < THREADS; i++)
|
|
err = pthread_join(threads[i].pt, NULL);
|
|
|
|
return err;
|
|
}
|
|
|
|
typedef int (*synth_cb)(struct machine *machine);
|
|
|
|
static int synth_all(struct machine *machine)
|
|
{
|
|
return perf_event__synthesize_threads(NULL,
|
|
perf_event__process,
|
|
machine, 1, 0, 1);
|
|
}
|
|
|
|
static int synth_process(struct machine *machine)
|
|
{
|
|
struct perf_thread_map *map;
|
|
int err;
|
|
|
|
map = thread_map__new_by_pid(getpid());
|
|
|
|
err = perf_event__synthesize_thread_map(NULL, map,
|
|
perf_event__process,
|
|
machine, 1, 0);
|
|
|
|
perf_thread_map__put(map);
|
|
return err;
|
|
}
|
|
|
|
static int mmap_events(synth_cb synth)
|
|
{
|
|
struct machine *machine;
|
|
int err, i;
|
|
|
|
/*
|
|
* The threads_create will not return before all threads
|
|
* are spawned and all created memory map.
|
|
*
|
|
* They will loop until threads_destroy is called, so we
|
|
* can safely run synthesizing function.
|
|
*/
|
|
TEST_ASSERT_VAL("failed to create threads", !threads_create());
|
|
|
|
machine = machine__new_host();
|
|
|
|
dump_trace = verbose > 1 ? 1 : 0;
|
|
|
|
err = synth(machine);
|
|
|
|
dump_trace = 0;
|
|
|
|
TEST_ASSERT_VAL("failed to destroy threads", !threads_destroy());
|
|
TEST_ASSERT_VAL("failed to synthesize maps", !err);
|
|
|
|
/*
|
|
* All data is synthesized, try to find map for each
|
|
* thread object.
|
|
*/
|
|
for (i = 0; i < THREADS; i++) {
|
|
struct thread_data *td = &threads[i];
|
|
struct addr_location al;
|
|
struct thread *thread;
|
|
|
|
addr_location__init(&al);
|
|
thread = machine__findnew_thread(machine, getpid(), td->tid);
|
|
|
|
pr_debug("looking for map %p\n", td->map);
|
|
|
|
thread__find_map(thread, PERF_RECORD_MISC_USER,
|
|
(unsigned long) (td->map + 1), &al);
|
|
|
|
thread__put(thread);
|
|
|
|
if (!al.map) {
|
|
pr_debug("failed, couldn't find map\n");
|
|
err = -1;
|
|
addr_location__exit(&al);
|
|
break;
|
|
}
|
|
|
|
pr_debug("map %p, addr %" PRIx64 "\n", al.map, map__start(al.map));
|
|
addr_location__exit(&al);
|
|
}
|
|
|
|
machine__delete(machine);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* This test creates 'THREADS' number of threads (including
|
|
* main thread) and each thread creates memory map.
|
|
*
|
|
* When threads are created, we synthesize them with both
|
|
* (separate tests):
|
|
* perf_event__synthesize_thread_map (process based)
|
|
* perf_event__synthesize_threads (global)
|
|
*
|
|
* We test we can find all memory maps via:
|
|
* thread__find_map
|
|
*
|
|
* by using all thread objects.
|
|
*/
|
|
static int test__mmap_thread_lookup(struct test_suite *test __maybe_unused, int subtest __maybe_unused)
|
|
{
|
|
/* perf_event__synthesize_threads synthesize */
|
|
TEST_ASSERT_VAL("failed with sythesizing all",
|
|
!mmap_events(synth_all));
|
|
|
|
/* perf_event__synthesize_thread_map synthesize */
|
|
TEST_ASSERT_VAL("failed with sythesizing process",
|
|
!mmap_events(synth_process));
|
|
|
|
return 0;
|
|
}
|
|
|
|
DEFINE_SUITE("Lookup mmap thread", mmap_thread_lookup);
|