1#include <sys/types.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <stdio.h>
5#include <inttypes.h>
6#include <ctype.h>
7#include <string.h>
8
9#include "parse-events.h"
10#include "evlist.h"
11#include "evsel.h"
12#include "thread_map.h"
13#include "cpumap.h"
14#include "machine.h"
15#include "event.h"
16#include "thread.h"
17
18#include "tests.h"
19
20#define BUFSZ	1024
21#define READLEN	128
22
23struct state {
24	u64 done[1024];
25	size_t done_cnt;
26};
27
28static unsigned int hex(char c)
29{
30	if (c >= '0' && c <= '9')
31		return c - '0';
32	if (c >= 'a' && c <= 'f')
33		return c - 'a' + 10;
34	return c - 'A' + 10;
35}
36
37static void read_objdump_line(const char *line, size_t line_len, void **buf,
38			      size_t *len)
39{
40	const char *p;
41	size_t i;
42
43	/* Skip to a colon */
44	p = strchr(line, ':');
45	if (!p)
46		return;
47	i = p + 1 - line;
48
49	/* Read bytes */
50	while (*len) {
51		char c1, c2;
52
53		/* Skip spaces */
54		for (; i < line_len; i++) {
55			if (!isspace(line[i]))
56				break;
57		}
58		/* Get 2 hex digits */
59		if (i >= line_len || !isxdigit(line[i]))
60			break;
61		c1 = line[i++];
62		if (i >= line_len || !isxdigit(line[i]))
63			break;
64		c2 = line[i++];
65		/* Followed by a space */
66		if (i < line_len && line[i] && !isspace(line[i]))
67			break;
68		/* Store byte */
69		*(unsigned char *)*buf = (hex(c1) << 4) | hex(c2);
70		*buf += 1;
71		*len -= 1;
72	}
73}
74
75static int read_objdump_output(FILE *f, void **buf, size_t *len)
76{
77	char *line = NULL;
78	size_t line_len;
79	ssize_t ret;
80	int err = 0;
81
82	while (1) {
83		ret = getline(&line, &line_len, f);
84		if (feof(f))
85			break;
86		if (ret < 0) {
87			pr_debug("getline failed\n");
88			err = -1;
89			break;
90		}
91		read_objdump_line(line, ret, buf, len);
92	}
93
94	free(line);
95
96	return err;
97}
98
99static int read_via_objdump(const char *filename, u64 addr, void *buf,
100			    size_t len)
101{
102	char cmd[PATH_MAX * 2];
103	const char *fmt;
104	FILE *f;
105	int ret;
106
107	fmt = "%s -d --start-address=0x%"PRIx64" --stop-address=0x%"PRIx64" %s";
108	ret = snprintf(cmd, sizeof(cmd), fmt, "objdump", addr, addr + len,
109		       filename);
110	if (ret <= 0 || (size_t)ret >= sizeof(cmd))
111		return -1;
112
113	pr_debug("Objdump command is: %s\n", cmd);
114
115	/* Ignore objdump errors */
116	strcat(cmd, " 2>/dev/null");
117
118	f = popen(cmd, "r");
119	if (!f) {
120		pr_debug("popen failed\n");
121		return -1;
122	}
123
124	ret = read_objdump_output(f, &buf, &len);
125	if (len) {
126		pr_debug("objdump read too few bytes\n");
127		if (!ret)
128			ret = len;
129	}
130
131	pclose(f);
132
133	return ret;
134}
135
136static int read_object_code(u64 addr, size_t len, u8 cpumode,
137			    struct thread *thread, struct machine *machine,
138			    struct state *state)
139{
140	struct addr_location al;
141	unsigned char buf1[BUFSZ];
142	unsigned char buf2[BUFSZ];
143	size_t ret_len;
144	u64 objdump_addr;
145	int ret;
146
147	pr_debug("Reading object code for memory address: %#"PRIx64"\n", addr);
148
149	thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION, addr,
150			      &al);
151	if (!al.map || !al.map->dso) {
152		pr_debug("thread__find_addr_map failed\n");
153		return -1;
154	}
155
156	pr_debug("File is: %s\n", al.map->dso->long_name);
157
158	if (al.map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
159	    !dso__is_kcore(al.map->dso)) {
160		pr_debug("Unexpected kernel address - skipping\n");
161		return 0;
162	}
163
164	pr_debug("On file address is: %#"PRIx64"\n", al.addr);
165
166	if (len > BUFSZ)
167		len = BUFSZ;
168
169	/* Do not go off the map */
170	if (addr + len > al.map->end)
171		len = al.map->end - addr;
172
173	/* Read the object code using perf */
174	ret_len = dso__data_read_offset(al.map->dso, machine, al.addr, buf1,
175					len);
176	if (ret_len != len) {
177		pr_debug("dso__data_read_offset failed\n");
178		return -1;
179	}
180
181	/*
182	 * Converting addresses for use by objdump requires more information.
183	 * map__load() does that.  See map__rip_2objdump() for details.
184	 */
185	if (map__load(al.map, NULL))
186		return -1;
187
188	/* objdump struggles with kcore - try each map only once */
189	if (dso__is_kcore(al.map->dso)) {
190		size_t d;
191
192		for (d = 0; d < state->done_cnt; d++) {
193			if (state->done[d] == al.map->start) {
194				pr_debug("kcore map tested already");
195				pr_debug(" - skipping\n");
196				return 0;
197			}
198		}
199		if (state->done_cnt >= ARRAY_SIZE(state->done)) {
200			pr_debug("Too many kcore maps - skipping\n");
201			return 0;
202		}
203		state->done[state->done_cnt++] = al.map->start;
204	}
205
206	/* Read the object code using objdump */
207	objdump_addr = map__rip_2objdump(al.map, al.addr);
208	ret = read_via_objdump(al.map->dso->long_name, objdump_addr, buf2, len);
209	if (ret > 0) {
210		/*
211		 * The kernel maps are inaccurate - assume objdump is right in
212		 * that case.
213		 */
214		if (cpumode == PERF_RECORD_MISC_KERNEL ||
215		    cpumode == PERF_RECORD_MISC_GUEST_KERNEL) {
216			len -= ret;
217			if (len) {
218				pr_debug("Reducing len to %zu\n", len);
219			} else if (dso__is_kcore(al.map->dso)) {
220				/*
221				 * objdump cannot handle very large segments
222				 * that may be found in kcore.
223				 */
224				pr_debug("objdump failed for kcore");
225				pr_debug(" - skipping\n");
226				return 0;
227			} else {
228				return -1;
229			}
230		}
231	}
232	if (ret < 0) {
233		pr_debug("read_via_objdump failed\n");
234		return -1;
235	}
236
237	/* The results should be identical */
238	if (memcmp(buf1, buf2, len)) {
239		pr_debug("Bytes read differ from those read by objdump\n");
240		return -1;
241	}
242	pr_debug("Bytes read match those read by objdump\n");
243
244	return 0;
245}
246
247static int process_sample_event(struct machine *machine,
248				struct perf_evlist *evlist,
249				union perf_event *event, struct state *state)
250{
251	struct perf_sample sample;
252	struct thread *thread;
253	u8 cpumode;
254
255	if (perf_evlist__parse_sample(evlist, event, &sample)) {
256		pr_debug("perf_evlist__parse_sample failed\n");
257		return -1;
258	}
259
260	thread = machine__findnew_thread(machine, sample.pid, sample.pid);
261	if (!thread) {
262		pr_debug("machine__findnew_thread failed\n");
263		return -1;
264	}
265
266	cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
267
268	return read_object_code(sample.ip, READLEN, cpumode, thread, machine,
269				state);
270}
271
272static int process_event(struct machine *machine, struct perf_evlist *evlist,
273			 union perf_event *event, struct state *state)
274{
275	if (event->header.type == PERF_RECORD_SAMPLE)
276		return process_sample_event(machine, evlist, event, state);
277
278	if (event->header.type < PERF_RECORD_MAX)
279		return machine__process_event(machine, event);
280
281	return 0;
282}
283
284static int process_events(struct machine *machine, struct perf_evlist *evlist,
285			  struct state *state)
286{
287	union perf_event *event;
288	int i, ret;
289
290	for (i = 0; i < evlist->nr_mmaps; i++) {
291		while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
292			ret = process_event(machine, evlist, event, state);
293			perf_evlist__mmap_consume(evlist, i);
294			if (ret < 0)
295				return ret;
296		}
297	}
298	return 0;
299}
300
301static int comp(const void *a, const void *b)
302{
303	return *(int *)a - *(int *)b;
304}
305
306static void do_sort_something(void)
307{
308	int buf[40960], i;
309
310	for (i = 0; i < (int)ARRAY_SIZE(buf); i++)
311		buf[i] = ARRAY_SIZE(buf) - i - 1;
312
313	qsort(buf, ARRAY_SIZE(buf), sizeof(int), comp);
314
315	for (i = 0; i < (int)ARRAY_SIZE(buf); i++) {
316		if (buf[i] != i) {
317			pr_debug("qsort failed\n");
318			break;
319		}
320	}
321}
322
323static void sort_something(void)
324{
325	int i;
326
327	for (i = 0; i < 10; i++)
328		do_sort_something();
329}
330
331static void syscall_something(void)
332{
333	int pipefd[2];
334	int i;
335
336	for (i = 0; i < 1000; i++) {
337		if (pipe(pipefd) < 0) {
338			pr_debug("pipe failed\n");
339			break;
340		}
341		close(pipefd[1]);
342		close(pipefd[0]);
343	}
344}
345
346static void fs_something(void)
347{
348	const char *test_file_name = "temp-perf-code-reading-test-file--";
349	FILE *f;
350	int i;
351
352	for (i = 0; i < 1000; i++) {
353		f = fopen(test_file_name, "w+");
354		if (f) {
355			fclose(f);
356			unlink(test_file_name);
357		}
358	}
359}
360
361static void do_something(void)
362{
363	fs_something();
364
365	sort_something();
366
367	syscall_something();
368}
369
370enum {
371	TEST_CODE_READING_OK,
372	TEST_CODE_READING_NO_VMLINUX,
373	TEST_CODE_READING_NO_KCORE,
374	TEST_CODE_READING_NO_ACCESS,
375	TEST_CODE_READING_NO_KERNEL_OBJ,
376};
377
378static int do_test_code_reading(bool try_kcore)
379{
380	struct machines machines;
381	struct machine *machine;
382	struct thread *thread;
383	struct perf_record_opts opts = {
384		.mmap_pages	     = UINT_MAX,
385		.user_freq	     = UINT_MAX,
386		.user_interval	     = ULLONG_MAX,
387		.freq		     = 4000,
388		.target		     = {
389			.uses_mmap   = true,
390		},
391	};
392	struct state state = {
393		.done_cnt = 0,
394	};
395	struct thread_map *threads = NULL;
396	struct cpu_map *cpus = NULL;
397	struct perf_evlist *evlist = NULL;
398	struct perf_evsel *evsel = NULL;
399	int err = -1, ret;
400	pid_t pid;
401	struct map *map;
402	bool have_vmlinux, have_kcore, excl_kernel = false;
403
404	pid = getpid();
405
406	machines__init(&machines);
407	machine = &machines.host;
408
409	ret = machine__create_kernel_maps(machine);
410	if (ret < 0) {
411		pr_debug("machine__create_kernel_maps failed\n");
412		goto out_err;
413	}
414
415	/* Force the use of kallsyms instead of vmlinux to try kcore */
416	if (try_kcore)
417		symbol_conf.kallsyms_name = "/proc/kallsyms";
418
419	/* Load kernel map */
420	map = machine->vmlinux_maps[MAP__FUNCTION];
421	ret = map__load(map, NULL);
422	if (ret < 0) {
423		pr_debug("map__load failed\n");
424		goto out_err;
425	}
426	have_vmlinux = dso__is_vmlinux(map->dso);
427	have_kcore = dso__is_kcore(map->dso);
428
429	/* 2nd time through we just try kcore */
430	if (try_kcore && !have_kcore)
431		return TEST_CODE_READING_NO_KCORE;
432
433	/* No point getting kernel events if there is no kernel object */
434	if (!have_vmlinux && !have_kcore)
435		excl_kernel = true;
436
437	threads = thread_map__new_by_tid(pid);
438	if (!threads) {
439		pr_debug("thread_map__new_by_tid failed\n");
440		goto out_err;
441	}
442
443	ret = perf_event__synthesize_thread_map(NULL, threads,
444						perf_event__process, machine);
445	if (ret < 0) {
446		pr_debug("perf_event__synthesize_thread_map failed\n");
447		goto out_err;
448	}
449
450	thread = machine__findnew_thread(machine, pid, pid);
451	if (!thread) {
452		pr_debug("machine__findnew_thread failed\n");
453		goto out_err;
454	}
455
456	cpus = cpu_map__new(NULL);
457	if (!cpus) {
458		pr_debug("cpu_map__new failed\n");
459		goto out_err;
460	}
461
462	while (1) {
463		const char *str;
464
465		evlist = perf_evlist__new();
466		if (!evlist) {
467			pr_debug("perf_evlist__new failed\n");
468			goto out_err;
469		}
470
471		perf_evlist__set_maps(evlist, cpus, threads);
472
473		if (excl_kernel)
474			str = "cycles:u";
475		else
476			str = "cycles";
477		pr_debug("Parsing event '%s'\n", str);
478		ret = parse_events(evlist, str);
479		if (ret < 0) {
480			pr_debug("parse_events failed\n");
481			goto out_err;
482		}
483
484		perf_evlist__config(evlist, &opts);
485
486		evsel = perf_evlist__first(evlist);
487
488		evsel->attr.comm = 1;
489		evsel->attr.disabled = 1;
490		evsel->attr.enable_on_exec = 0;
491
492		ret = perf_evlist__open(evlist);
493		if (ret < 0) {
494			if (!excl_kernel) {
495				excl_kernel = true;
496				perf_evlist__delete(evlist);
497				evlist = NULL;
498				continue;
499			}
500			pr_debug("perf_evlist__open failed\n");
501			goto out_err;
502		}
503		break;
504	}
505
506	ret = perf_evlist__mmap(evlist, UINT_MAX, false);
507	if (ret < 0) {
508		pr_debug("perf_evlist__mmap failed\n");
509		goto out_err;
510	}
511
512	perf_evlist__enable(evlist);
513
514	do_something();
515
516	perf_evlist__disable(evlist);
517
518	ret = process_events(machine, evlist, &state);
519	if (ret < 0)
520		goto out_err;
521
522	if (!have_vmlinux && !have_kcore && !try_kcore)
523		err = TEST_CODE_READING_NO_KERNEL_OBJ;
524	else if (!have_vmlinux && !try_kcore)
525		err = TEST_CODE_READING_NO_VMLINUX;
526	else if (excl_kernel)
527		err = TEST_CODE_READING_NO_ACCESS;
528	else
529		err = TEST_CODE_READING_OK;
530out_err:
531	if (evlist) {
532		perf_evlist__munmap(evlist);
533		perf_evlist__close(evlist);
534		perf_evlist__delete(evlist);
535	}
536	if (cpus)
537		cpu_map__delete(cpus);
538	if (threads)
539		thread_map__delete(threads);
540	machines__destroy_kernel_maps(&machines);
541	machine__delete_threads(machine);
542	machines__exit(&machines);
543
544	return err;
545}
546
547int test__code_reading(void)
548{
549	int ret;
550
551	ret = do_test_code_reading(false);
552	if (!ret)
553		ret = do_test_code_reading(true);
554
555	switch (ret) {
556	case TEST_CODE_READING_OK:
557		return 0;
558	case TEST_CODE_READING_NO_VMLINUX:
559		fprintf(stderr, " (no vmlinux)");
560		return 0;
561	case TEST_CODE_READING_NO_KCORE:
562		fprintf(stderr, " (no kcore)");
563		return 0;
564	case TEST_CODE_READING_NO_ACCESS:
565		fprintf(stderr, " (no access)");
566		return 0;
567	case TEST_CODE_READING_NO_KERNEL_OBJ:
568		fprintf(stderr, " (no kernel obj)");
569		return 0;
570	default:
571		return -1;
572	};
573}
574