~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/tests/code-reading.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp