1// SPDX-License-Identifier: GPL-2.0
  2#include <inttypes.h>
  3#include "perf.h"
  4#include "util/debug.h"
  5#include "util/symbol.h"
  6#include "util/sort.h"
  7#include "util/evsel.h"
  8#include "util/evlist.h"
  9#include "util/machine.h"
 10#include "util/thread.h"
 11#include "tests/hists_common.h"
 12#include <linux/kernel.h>
 13
 14static struct {
 15	u32 pid;
 16	const char *comm;
 17} fake_threads[] = {
 18	{ FAKE_PID_PERF1, "perf" },
 19	{ FAKE_PID_PERF2, "perf" },
 20	{ FAKE_PID_BASH,  "bash" },
 21};
 22
 23static struct {
 24	u32 pid;
 25	u64 start;
 26	const char *filename;
 27} fake_mmap_info[] = {
 28	{ FAKE_PID_PERF1, FAKE_MAP_PERF,   "perf" },
 29	{ FAKE_PID_PERF1, FAKE_MAP_LIBC,   "libc" },
 30	{ FAKE_PID_PERF1, FAKE_MAP_KERNEL, "[kernel]" },
 31	{ FAKE_PID_PERF2, FAKE_MAP_PERF,   "perf" },
 32	{ FAKE_PID_PERF2, FAKE_MAP_LIBC,   "libc" },
 33	{ FAKE_PID_PERF2, FAKE_MAP_KERNEL, "[kernel]" },
 34	{ FAKE_PID_BASH,  FAKE_MAP_BASH,   "bash" },
 35	{ FAKE_PID_BASH,  FAKE_MAP_LIBC,   "libc" },
 36	{ FAKE_PID_BASH,  FAKE_MAP_KERNEL, "[kernel]" },
 37};
 38
 39struct fake_sym {
 40	u64 start;
 41	u64 length;
 42	const char *name;
 43};
 44
 45static struct fake_sym perf_syms[] = {
 46	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
 47	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "run_command" },
 48	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "cmd_record" },
 49};
 50
 51static struct fake_sym bash_syms[] = {
 52	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "main" },
 53	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "xmalloc" },
 54	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "xfree" },
 55};
 56
 57static struct fake_sym libc_syms[] = {
 58	{ 700, 100, "malloc" },
 59	{ 800, 100, "free" },
 60	{ 900, 100, "realloc" },
 61	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "malloc" },
 62	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "free" },
 63	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "realloc" },
 64};
 65
 66static struct fake_sym kernel_syms[] = {
 67	{ FAKE_SYM_OFFSET1, FAKE_SYM_LENGTH, "schedule" },
 68	{ FAKE_SYM_OFFSET2, FAKE_SYM_LENGTH, "page_fault" },
 69	{ FAKE_SYM_OFFSET3, FAKE_SYM_LENGTH, "sys_perf_event_open" },
 70};
 71
 72static struct {
 73	const char *dso_name;
 74	struct fake_sym *syms;
 75	size_t nr_syms;
 76} fake_symbols[] = {
 77	{ "perf", perf_syms, ARRAY_SIZE(perf_syms) },
 78	{ "bash", bash_syms, ARRAY_SIZE(bash_syms) },
 79	{ "libc", libc_syms, ARRAY_SIZE(libc_syms) },
 80	{ "[kernel]", kernel_syms, ARRAY_SIZE(kernel_syms) },
 81};
 82
 83struct machine *setup_fake_machine(struct machines *machines)
 84{
 85	struct machine *machine = machines__find(machines, HOST_KERNEL_ID);
 86	size_t i;
 87
 88	if (machine == NULL) {
 89		pr_debug("Not enough memory for machine setup\n");
 90		return NULL;
 91	}
 92
 93	for (i = 0; i < ARRAY_SIZE(fake_threads); i++) {
 94		struct thread *thread;
 95
 96		thread = machine__findnew_thread(machine, fake_threads[i].pid,
 97						 fake_threads[i].pid);
 98		if (thread == NULL)
 99			goto out;
100
101		thread__set_comm(thread, fake_threads[i].comm, 0);
102		thread__put(thread);
103	}
104
105	for (i = 0; i < ARRAY_SIZE(fake_mmap_info); i++) {
106		struct perf_sample sample = {
107			.cpumode = PERF_RECORD_MISC_USER,
108		};
109		union perf_event fake_mmap_event = {
110			.mmap = {
111				.pid = fake_mmap_info[i].pid,
112				.tid = fake_mmap_info[i].pid,
113				.start = fake_mmap_info[i].start,
114				.len = FAKE_MAP_LENGTH,
115				.pgoff = 0ULL,
116			},
117		};
118
119		strcpy(fake_mmap_event.mmap.filename,
120		       fake_mmap_info[i].filename);
121
122		machine__process_mmap_event(machine, &fake_mmap_event, &sample);
123	}
124
125	for (i = 0; i < ARRAY_SIZE(fake_symbols); i++) {
126		size_t k;
127		struct dso *dso;
128
129		dso = machine__findnew_dso(machine, fake_symbols[i].dso_name);
130		if (dso == NULL)
131			goto out;
132
133		/* emulate dso__load() */
134		dso__set_loaded(dso, MAP__FUNCTION);
135
136		for (k = 0; k < fake_symbols[i].nr_syms; k++) {
137			struct symbol *sym;
138			struct fake_sym *fsym = &fake_symbols[i].syms[k];
139
140			sym = symbol__new(fsym->start, fsym->length,
141					  STB_GLOBAL, fsym->name);
142			if (sym == NULL) {
143				dso__put(dso);
144				goto out;
145			}
146
147			symbols__insert(&dso->symbols[MAP__FUNCTION], sym);
148		}
149
150		dso__put(dso);
151	}
152
153	return machine;
154
155out:
156	pr_debug("Not enough memory for machine setup\n");
157	machine__delete_threads(machine);
158	return NULL;
159}
160
161void print_hists_in(struct hists *hists)
162{
163	int i = 0;
164	struct rb_root *root;
165	struct rb_node *node;
166
167	if (hists__has(hists, need_collapse))
168		root = &hists->entries_collapsed;
169	else
170		root = hists->entries_in;
171
172	pr_info("----- %s --------\n", __func__);
173	node = rb_first(root);
174	while (node) {
175		struct hist_entry *he;
176
177		he = rb_entry(node, struct hist_entry, rb_node_in);
178
179		if (!he->filtered) {
180			pr_info("%2d: entry: %-8s [%-8s] %20s: period = %"PRIu64"\n",
181				i, thread__comm_str(he->thread),
182				he->ms.map->dso->short_name,
183				he->ms.sym->name, he->stat.period);
184		}
185
186		i++;
187		node = rb_next(node);
188	}
189}
190
191void print_hists_out(struct hists *hists)
192{
193	int i = 0;
194	struct rb_root *root;
195	struct rb_node *node;
196
197	root = &hists->entries;
198
199	pr_info("----- %s --------\n", __func__);
200	node = rb_first(root);
201	while (node) {
202		struct hist_entry *he;
203
204		he = rb_entry(node, struct hist_entry, rb_node);
205
206		if (!he->filtered) {
207			pr_info("%2d: entry: %8s:%5d [%-8s] %20s: period = %"PRIu64"/%"PRIu64"\n",
208				i, thread__comm_str(he->thread), he->thread->tid,
209				he->ms.map->dso->short_name,
210				he->ms.sym->name, he->stat.period,
211				he->stat_acc ? he->stat_acc->period : 0);
212		}
213
214		i++;
215		node = rb_next(node);
216	}
217}