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