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)
Using accessors will make it easier to add reference count checking in later patches. Committer notes: thread->nsinfo wasn't wrapped as it is used together with nsinfo__zput(), where does a trick to set the field with a refcount being dropped to NULL, and that doesn't work well with using thread__nsinfo(thread), that loses the &thread->nsinfo pointer. When refcount checking is added to 'struct thread', later in this series, nsinfo__zput(RC_CHK_ACCESS(thread)->nsinfo) will be used to check the thread pointer. 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-4-irogers@google.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
223 lines
5.2 KiB
C
223 lines
5.2 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <inttypes.h>
|
|
#include "util/debug.h"
|
|
#include "util/dso.h"
|
|
#include "util/event.h" // struct perf_sample
|
|
#include "util/map.h"
|
|
#include "util/symbol.h"
|
|
#include "util/sort.h"
|
|
#include "util/evsel.h"
|
|
#include "util/machine.h"
|
|
#include "util/thread.h"
|
|
#include "tests/hists_common.h"
|
|
#include <linux/kernel.h>
|
|
#include <linux/perf_event.h>
|
|
|
|
static struct {
|
|
u32 pid;
|
|
const char *comm;
|
|
} fake_threads[] = {
|
|
{ FAKE_PID_PERF1, "perf" },
|
|
{ FAKE_PID_PERF2, "perf" },
|
|
{ FAKE_PID_BASH, "bash" },
|
|
};
|
|
|
|
static struct {
|
|
u32 pid;
|
|
u64 start;
|
|
const char *filename;
|
|
} fake_mmap_info[] = {
|
|
{ FAKE_PID_PERF1, FAKE_MAP_PERF, "perf" },
|
|
{ FAKE_PID_PERF1, FAKE_MAP_LIBC, "libc" },
|
|
{ FAKE_PID_PERF1, FAKE_MAP_KERNEL, "[kernel]" },
|
|
{ FAKE_PID_PERF2, FAKE_MAP_PERF, "perf" },
|
|
{ FAKE_PID_PERF2, FAKE_MAP_LIBC, "libc" },
|
|
{ FAKE_PID_PERF2, FAKE_MAP_KERNEL, "[kernel]" },
|
|
{ FAKE_PID_BASH, FAKE_MAP_BASH, "bash" },
|
|
{ FAKE_PID_BASH, FAKE_MAP_LIBC, "libc" },
|
|
{ FAKE_PID_BASH, FAKE_MAP_KERNEL, "[kernel]" },
|
|
};
|
|
|
|
struct fake_sym {
|
|
u64 start;
|
|
u64 length;
|
|
const char *name;
|
|
};
|
|
|
|
static struct fake_sym perf_syms[] = {
|
|
{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
|
|
{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "run_command" },
|
|
{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "cmd_record" },
|
|
};
|
|
|
|
static struct fake_sym bash_syms[] = {
|
|
{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
|
|
{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "xmalloc" },
|
|
{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "xfree" },
|
|
};
|
|
|
|
static struct fake_sym libc_syms[] = {
|
|
{ 700, 100, "malloc" },
|
|
{ 800, 100, "free" },
|
|
{ 900, 100, "realloc" },
|
|
{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "malloc" },
|
|
{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "free" },
|
|
{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "realloc" },
|
|
};
|
|
|
|
static struct fake_sym kernel_syms[] = {
|
|
{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "schedule" },
|
|
{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "page_fault" },
|
|
{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "sys_perf_event_open" },
|
|
};
|
|
|
|
static struct {
|
|
const char *dso_name;
|
|
struct fake_sym *syms;
|
|
size_t nr_syms;
|
|
} fake_symbols[] = {
|
|
{ "perf", perf_syms, ARRAY_SIZE(perf_syms) },
|
|
{ "bash", bash_syms, ARRAY_SIZE(bash_syms) },
|
|
{ "libc", libc_syms, ARRAY_SIZE(libc_syms) },
|
|
{ "[kernel]", kernel_syms, ARRAY_SIZE(kernel_syms) },
|
|
};
|
|
|
|
struct machine *setup_fake_machine(struct machines *machines)
|
|
{
|
|
struct machine *machine = machines__find(machines, HOST_KERNEL_ID);
|
|
size_t i;
|
|
|
|
if (machine == NULL) {
|
|
pr_debug("Not enough memory for machine setup\n");
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
|
|
struct thread *thread;
|
|
|
|
thread = machine__findnew_thread(machine, fake_threads[i].pid,
|
|
fake_threads[i].pid);
|
|
if (thread == NULL)
|
|
goto out;
|
|
|
|
thread__set_comm(thread, fake_threads[i].comm, 0);
|
|
thread__put(thread);
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fake_mmap_info); i++) {
|
|
struct perf_sample sample = {
|
|
.cpumode = PERF_RECORD_MISC_USER,
|
|
};
|
|
union perf_event fake_mmap_event = {
|
|
.mmap = {
|
|
.pid = fake_mmap_info[i].pid,
|
|
.tid = fake_mmap_info[i].pid,
|
|
.start = fake_mmap_info[i].start,
|
|
.len = FAKE_MAP_LENGTH,
|
|
.pgoff = 0ULL,
|
|
},
|
|
};
|
|
|
|
strcpy(fake_mmap_event.mmap.filename,
|
|
fake_mmap_info[i].filename);
|
|
|
|
machine__process_mmap_event(machine, &fake_mmap_event, &sample);
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(fake_symbols); i++) {
|
|
size_t k;
|
|
struct dso *dso;
|
|
|
|
dso = machine__findnew_dso(machine, fake_symbols[i].dso_name);
|
|
if (dso == NULL)
|
|
goto out;
|
|
|
|
/* emulate dso__load() */
|
|
dso__set_loaded(dso);
|
|
|
|
for (k = 0; k < fake_symbols[i].nr_syms; k++) {
|
|
struct symbol *sym;
|
|
struct fake_sym *fsym = &fake_symbols[i].syms[k];
|
|
|
|
sym = symbol__new(fsym->start, fsym->length,
|
|
STB_GLOBAL, STT_FUNC, fsym->name);
|
|
if (sym == NULL) {
|
|
dso__put(dso);
|
|
goto out;
|
|
}
|
|
|
|
symbols__insert(&dso->symbols, sym);
|
|
}
|
|
|
|
dso__put(dso);
|
|
}
|
|
|
|
return machine;
|
|
|
|
out:
|
|
pr_debug("Not enough memory for machine setup\n");
|
|
machine__delete_threads(machine);
|
|
return NULL;
|
|
}
|
|
|
|
void print_hists_in(struct hists *hists)
|
|
{
|
|
int i = 0;
|
|
struct rb_root_cached *root;
|
|
struct rb_node *node;
|
|
|
|
if (hists__has(hists, need_collapse))
|
|
root = &hists->entries_collapsed;
|
|
else
|
|
root = hists->entries_in;
|
|
|
|
pr_info("----- %s --------\n", __func__);
|
|
node = rb_first_cached(root);
|
|
while (node) {
|
|
struct hist_entry *he;
|
|
|
|
he = rb_entry(node, struct hist_entry, rb_node_in);
|
|
|
|
if (!he->filtered) {
|
|
struct dso *dso = map__dso(he->ms.map);
|
|
|
|
pr_info("%2d: entry: %-8s [%-8s] %20s: period = %"PRIu64"\n",
|
|
i, thread__comm_str(he->thread),
|
|
dso->short_name,
|
|
he->ms.sym->name, he->stat.period);
|
|
}
|
|
|
|
i++;
|
|
node = rb_next(node);
|
|
}
|
|
}
|
|
|
|
void print_hists_out(struct hists *hists)
|
|
{
|
|
int i = 0;
|
|
struct rb_root_cached *root;
|
|
struct rb_node *node;
|
|
|
|
root = &hists->entries;
|
|
|
|
pr_info("----- %s --------\n", __func__);
|
|
node = rb_first_cached(root);
|
|
while (node) {
|
|
struct hist_entry *he;
|
|
|
|
he = rb_entry(node, struct hist_entry, rb_node);
|
|
|
|
if (!he->filtered) {
|
|
struct dso *dso = map__dso(he->ms.map);
|
|
|
|
pr_info("%2d: entry: %8s:%5d [%-8s] %20s: period = %"PRIu64"/%"PRIu64"\n",
|
|
i, thread__comm_str(he->thread), thread__tid(he->thread),
|
|
dso->short_name,
|
|
he->ms.sym->name, he->stat.period,
|
|
he->stat_acc ? he->stat_acc->period : 0);
|
|
}
|
|
|
|
i++;
|
|
node = rb_next(node);
|
|
}
|
|
}
|