1 // SPDX-License-Identifier: GPL-2.0
3 #include <linux/kernel.h>
4 #include <linux/types.h>
10 #include <sys/param.h>
11 #include <perf/cpumap.h>
12 #include <perf/evlist.h>
14 #include "parse-events.h"
17 #include "thread_map.h"
28 #include <linux/ctype.h>
38 static unsigned int hex(char c)
40 if (c >= '0' && c <= '9')
42 if (c >= 'a' && c <= 'f')
47 static size_t read_objdump_chunk(const char **line, unsigned char **buf,
50 size_t bytes_read = 0;
51 unsigned char *chunk_start = *buf;
54 while (*buf_len > 0) {
57 /* Get 2 hex digits */
65 /* Store byte and advance buf */
66 **buf = (hex(c1) << 4) | hex(c2);
77 * objdump will display raw insn as LE if code endian
78 * is LE and bytes_per_chunk > 1. In that case reverse
79 * the chunk we just read.
81 * see disassemble_bytes() at binutils/objdump.c for details
82 * how objdump chooses display endian)
84 if (bytes_read > 1 && !bigendian()) {
85 unsigned char *chunk_end = chunk_start + bytes_read - 1;
88 while (chunk_start < chunk_end) {
90 *chunk_start = *chunk_end;
100 static size_t read_objdump_line(const char *line, unsigned char *buf,
104 size_t ret, bytes_read = 0;
106 /* Skip to a colon */
107 p = strchr(line, ':');
112 /* Skip initial spaces */
120 ret = read_objdump_chunk(&p, &buf, &buf_len);
125 /* return number of successfully read bytes */
129 static int read_objdump_output(FILE *f, void *buf, size_t *len, u64 start_addr)
132 size_t line_len, off_last = 0;
135 u64 addr, last_addr = start_addr;
137 while (off_last < *len) {
138 size_t off, read_bytes, written_bytes;
139 unsigned char tmp[BUFSZ];
141 ret = getline(&line, &line_len, f);
145 pr_debug("getline failed\n");
150 /* read objdump data into temporary buffer */
151 read_bytes = read_objdump_line(line, tmp, sizeof(tmp));
155 if (sscanf(line, "%"PRIx64, &addr) != 1)
157 if (addr < last_addr) {
158 pr_debug("addr going backwards, read beyond section?\n");
163 /* copy it from temporary buffer to 'buf' according
164 * to address on current objdump line */
165 off = addr - start_addr;
168 written_bytes = MIN(read_bytes, *len - off);
169 memcpy(buf + off, tmp, written_bytes);
170 off_last = off + written_bytes;
173 /* len returns number of bytes that could not be read */
181 static int read_via_objdump(const char *filename, u64 addr, void *buf,
184 char cmd[PATH_MAX * 2];
189 fmt = "%s -z -d --start-address=0x%"PRIx64" --stop-address=0x%"PRIx64" %s";
190 ret = snprintf(cmd, sizeof(cmd), fmt, "objdump", addr, addr + len,
192 if (ret <= 0 || (size_t)ret >= sizeof(cmd))
195 pr_debug("Objdump command is: %s\n", cmd);
197 /* Ignore objdump errors */
198 strcat(cmd, " 2>/dev/null");
202 pr_debug("popen failed\n");
206 ret = read_objdump_output(f, buf, &len, addr);
208 pr_debug("objdump read too few bytes: %zd\n", len);
218 static void dump_buf(unsigned char *buf, size_t len)
222 for (i = 0; i < len; i++) {
223 pr_debug("0x%02x ", buf[i]);
230 static int read_object_code(u64 addr, size_t len, u8 cpumode,
231 struct thread *thread, struct state *state)
233 struct addr_location al;
234 unsigned char buf1[BUFSZ];
235 unsigned char buf2[BUFSZ];
238 const char *objdump_name;
239 char decomp_name[KMOD_DECOMP_LEN];
243 pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
245 if (!thread__find_map(thread, cpumode, addr, &al) || !al.map->dso) {
246 if (cpumode == PERF_RECORD_MISC_HYPERVISOR) {
247 pr_debug("Hypervisor address can not be resolved - skipping\n");
251 pr_debug("thread__find_map failed\n");
255 pr_debug("File is: %s\n", al.map->dso->long_name);
257 if (al.map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
258 !dso__is_kcore(al.map->dso)) {
259 pr_debug("Unexpected kernel address - skipping\n");
263 pr_debug("On file address is: %#"PRIx64"\n", al.addr);
268 /* Do not go off the map */
269 if (addr + len > al.map->end)
270 len = al.map->end - addr;
272 /* Read the object code using perf */
273 ret_len = dso__data_read_offset(al.map->dso, thread->mg->machine,
275 if (ret_len != len) {
276 pr_debug("dso__data_read_offset failed\n");
281 * Converting addresses for use by objdump requires more information.
282 * map__load() does that. See map__rip_2objdump() for details.
284 if (map__load(al.map))
287 /* objdump struggles with kcore - try each map only once */
288 if (dso__is_kcore(al.map->dso)) {
291 for (d = 0; d < state->done_cnt; d++) {
292 if (state->done[d] == al.map->start) {
293 pr_debug("kcore map tested already");
294 pr_debug(" - skipping\n");
298 if (state->done_cnt >= ARRAY_SIZE(state->done)) {
299 pr_debug("Too many kcore maps - skipping\n");
302 state->done[state->done_cnt++] = al.map->start;
305 objdump_name = al.map->dso->long_name;
306 if (dso__needs_decompress(al.map->dso)) {
307 if (dso__decompress_kmodule_path(al.map->dso, objdump_name,
309 sizeof(decomp_name)) < 0) {
310 pr_debug("decompression failed\n");
315 objdump_name = decomp_name;
318 /* Read the object code using objdump */
319 objdump_addr = map__rip_2objdump(al.map, al.addr);
320 ret = read_via_objdump(objdump_name, objdump_addr, buf2, len);
323 unlink(objdump_name);
327 * The kernel maps are inaccurate - assume objdump is right in
330 if (cpumode == PERF_RECORD_MISC_KERNEL ||
331 cpumode == PERF_RECORD_MISC_GUEST_KERNEL) {
334 pr_debug("Reducing len to %zu\n", len);
335 } else if (dso__is_kcore(al.map->dso)) {
337 * objdump cannot handle very large segments
338 * that may be found in kcore.
340 pr_debug("objdump failed for kcore");
341 pr_debug(" - skipping\n");
349 pr_debug("read_via_objdump failed\n");
353 /* The results should be identical */
354 if (memcmp(buf1, buf2, len)) {
355 pr_debug("Bytes read differ from those read by objdump\n");
356 pr_debug("buf1 (dso):\n");
358 pr_debug("buf2 (objdump):\n");
362 pr_debug("Bytes read match those read by objdump\n");
367 static int process_sample_event(struct machine *machine,
368 struct evlist *evlist,
369 union perf_event *event, struct state *state)
371 struct perf_sample sample;
372 struct thread *thread;
375 if (perf_evlist__parse_sample(evlist, event, &sample)) {
376 pr_debug("perf_evlist__parse_sample failed\n");
380 thread = machine__findnew_thread(machine, sample.pid, sample.tid);
382 pr_debug("machine__findnew_thread failed\n");
386 ret = read_object_code(sample.ip, READLEN, sample.cpumode, thread, state);
391 static int process_event(struct machine *machine, struct evlist *evlist,
392 union perf_event *event, struct state *state)
394 if (event->header.type == PERF_RECORD_SAMPLE)
395 return process_sample_event(machine, evlist, event, state);
397 if (event->header.type == PERF_RECORD_THROTTLE ||
398 event->header.type == PERF_RECORD_UNTHROTTLE)
401 if (event->header.type < PERF_RECORD_MAX) {
404 ret = machine__process_event(machine, event, NULL);
406 pr_debug("machine__process_event failed, event type %u\n",
414 static int process_events(struct machine *machine, struct evlist *evlist,
417 union perf_event *event;
418 struct perf_mmap *md;
421 for (i = 0; i < evlist->nr_mmaps; i++) {
422 md = &evlist->mmap[i];
423 if (perf_mmap__read_init(md) < 0)
426 while ((event = perf_mmap__read_event(md)) != NULL) {
427 ret = process_event(machine, evlist, event, state);
428 perf_mmap__consume(md);
432 perf_mmap__read_done(md);
437 static int comp(const void *a, const void *b)
439 return *(int *)a - *(int *)b;
442 static void do_sort_something(void)
446 for (i = 0; i < (int)ARRAY_SIZE(buf); i++)
447 buf[i] = ARRAY_SIZE(buf) - i - 1;
449 qsort(buf, ARRAY_SIZE(buf), sizeof(int), comp);
451 for (i = 0; i < (int)ARRAY_SIZE(buf); i++) {
453 pr_debug("qsort failed\n");
459 static void sort_something(void)
463 for (i = 0; i < 10; i++)
467 static void syscall_something(void)
472 for (i = 0; i < 1000; i++) {
473 if (pipe(pipefd) < 0) {
474 pr_debug("pipe failed\n");
482 static void fs_something(void)
484 const char *test_file_name = "temp-perf-code-reading-test-file--";
488 for (i = 0; i < 1000; i++) {
489 f = fopen(test_file_name, "w+");
492 unlink(test_file_name);
497 static const char *do_determine_event(bool excl_kernel)
499 const char *event = excl_kernel ? "cycles:u" : "cycles";
502 char cpuid[128], model[16], model_c[16], cpum_cf_v[16];
506 if (get_cpuid(cpuid, sizeof(cpuid)))
508 ret = sscanf(cpuid, "%*[^,],%u,%[^,],%[^,],%[^,],%x", &family, model_c,
509 model, cpum_cf_v, &cpum_cf_a);
510 if (ret != 5) /* Not available */
512 if (excl_kernel && (cpum_cf_a & 4))
514 if (!excl_kernel && (cpum_cf_a & 2))
517 /* Fall through: missing authorization */
519 event = excl_kernel ? "cpu-clock:u" : "cpu-clock";
525 static void do_something(void)
535 TEST_CODE_READING_OK,
536 TEST_CODE_READING_NO_VMLINUX,
537 TEST_CODE_READING_NO_KCORE,
538 TEST_CODE_READING_NO_ACCESS,
539 TEST_CODE_READING_NO_KERNEL_OBJ,
542 static int do_test_code_reading(bool try_kcore)
544 struct machine *machine;
545 struct thread *thread;
546 struct record_opts opts = {
547 .mmap_pages = UINT_MAX,
548 .user_freq = UINT_MAX,
549 .user_interval = ULLONG_MAX,
555 struct state state = {
558 struct perf_thread_map *threads = NULL;
559 struct perf_cpu_map *cpus = NULL;
560 struct evlist *evlist = NULL;
561 struct evsel *evsel = NULL;
565 bool have_vmlinux, have_kcore, excl_kernel = false;
569 machine = machine__new_host();
570 machine->env = &perf_env;
572 ret = machine__create_kernel_maps(machine);
574 pr_debug("machine__create_kernel_maps failed\n");
578 /* Force the use of kallsyms instead of vmlinux to try kcore */
580 symbol_conf.kallsyms_name = "/proc/kallsyms";
582 /* Load kernel map */
583 map = machine__kernel_map(machine);
584 ret = map__load(map);
586 pr_debug("map__load failed\n");
589 have_vmlinux = dso__is_vmlinux(map->dso);
590 have_kcore = dso__is_kcore(map->dso);
592 /* 2nd time through we just try kcore */
593 if (try_kcore && !have_kcore)
594 return TEST_CODE_READING_NO_KCORE;
596 /* No point getting kernel events if there is no kernel object */
597 if (!have_vmlinux && !have_kcore)
600 threads = thread_map__new_by_tid(pid);
602 pr_debug("thread_map__new_by_tid failed\n");
606 ret = perf_event__synthesize_thread_map(NULL, threads,
607 perf_event__process, machine, false);
609 pr_debug("perf_event__synthesize_thread_map failed\n");
613 thread = machine__findnew_thread(machine, pid, pid);
615 pr_debug("machine__findnew_thread failed\n");
619 cpus = perf_cpu_map__new(NULL);
621 pr_debug("perf_cpu_map__new failed\n");
628 evlist = evlist__new();
630 pr_debug("perf_evlist__new failed\n");
634 perf_evlist__set_maps(&evlist->core, cpus, threads);
636 str = do_determine_event(excl_kernel);
637 pr_debug("Parsing event '%s'\n", str);
638 ret = parse_events(evlist, str, NULL);
640 pr_debug("parse_events failed\n");
644 perf_evlist__config(evlist, &opts, NULL);
646 evsel = perf_evlist__first(evlist);
648 evsel->core.attr.comm = 1;
649 evsel->core.attr.disabled = 1;
650 evsel->core.attr.enable_on_exec = 0;
652 ret = evlist__open(evlist);
657 * Both cpus and threads are now owned by evlist
658 * and will be freed by following perf_evlist__set_maps
659 * call. Getting refference to keep them alive.
661 perf_cpu_map__get(cpus);
662 perf_thread_map__get(threads);
663 perf_evlist__set_maps(&evlist->core, NULL, NULL);
664 evlist__delete(evlist);
671 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
672 pr_debug("perf_evlist__open() failed!\n%s\n", errbuf);
680 ret = perf_evlist__mmap(evlist, UINT_MAX);
682 pr_debug("perf_evlist__mmap failed\n");
686 evlist__enable(evlist);
690 evlist__disable(evlist);
692 ret = process_events(machine, evlist, &state);
696 if (!have_vmlinux && !have_kcore && !try_kcore)
697 err = TEST_CODE_READING_NO_KERNEL_OBJ;
698 else if (!have_vmlinux && !try_kcore)
699 err = TEST_CODE_READING_NO_VMLINUX;
700 else if (excl_kernel)
701 err = TEST_CODE_READING_NO_ACCESS;
703 err = TEST_CODE_READING_OK;
709 evlist__delete(evlist);
711 perf_cpu_map__put(cpus);
712 perf_thread_map__put(threads);
714 machine__delete_threads(machine);
715 machine__delete(machine);
720 int test__code_reading(struct test *test __maybe_unused, int subtest __maybe_unused)
724 ret = do_test_code_reading(false);
726 ret = do_test_code_reading(true);
729 case TEST_CODE_READING_OK:
731 case TEST_CODE_READING_NO_VMLINUX:
732 pr_debug("no vmlinux\n");
734 case TEST_CODE_READING_NO_KCORE:
735 pr_debug("no kcore\n");
737 case TEST_CODE_READING_NO_ACCESS:
738 pr_debug("no access\n");
740 case TEST_CODE_READING_NO_KERNEL_OBJ:
741 pr_debug("no kernel obj\n");