projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[deliverable/linux.git] / tools / perf / builtin-trace.c
1 /*
2 * builtin-trace.c
3 *
4 * Builtin 'trace' command:
5 *
6 * Display a continuously updated trace of any workload, CPU, specific PID,
7 * system wide, etc. Default format is loosely strace like, but any other
8 * event may be specified using --event.
9 *
10 * Copyright (C) 2012, 2013, 2014, 2015 Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
11 *
12 * Initially based on the 'trace' prototype by Thomas Gleixner:
13 *
14 * http://lwn.net/Articles/415728/ ("Announcing a new utility: 'trace'")
15 *
16 * Released under the GPL v2. (and only v2, not any later version)
17 */
18
19 #include <traceevent/event-parse.h>
20 #include <api/fs/tracing_path.h>
21 #include "builtin.h"
22 #include "util/color.h"
23 #include "util/debug.h"
24 #include "util/evlist.h"
25 #include <subcmd/exec-cmd.h>
26 #include "util/machine.h"
27 #include "util/session.h"
28 #include "util/thread.h"
29 #include <subcmd/parse-options.h>
30 #include "util/strlist.h"
31 #include "util/intlist.h"
32 #include "util/thread_map.h"
33 #include "util/stat.h"
34 #include "trace-event.h"
35 #include "util/parse-events.h"
36 #include "util/bpf-loader.h"
37 #include "callchain.h"
38 #include "syscalltbl.h"
39 #include "rb_resort.h"
40
41 #include <libaudit.h> /* FIXME: Still needed for audit_errno_to_name */
42 #include <stdlib.h>
43 #include <linux/err.h>
44 #include <linux/filter.h>
45 #include <linux/audit.h>
46 #include <sys/ptrace.h>
47 #include <linux/random.h>
48 #include <linux/stringify.h>
49
50 #ifndef O_CLOEXEC
51 # define O_CLOEXEC 02000000
52 #endif
53
54 struct trace {
55 struct perf_tool tool;
56 struct syscalltbl *sctbl;
57 struct {
58 int max;
59 struct syscall *table;
60 struct {
61 struct perf_evsel *sys_enter,
62 *sys_exit;
63 } events;
64 } syscalls;
65 struct record_opts opts;
66 struct perf_evlist *evlist;
67 struct machine *host;
68 struct thread *current;
69 u64 base_time;
70 FILE *output;
71 unsigned long nr_events;
72 struct strlist *ev_qualifier;
73 struct {
74 size_t nr;
75 int *entries;
76 } ev_qualifier_ids;
77 struct intlist *tid_list;
78 struct intlist *pid_list;
79 struct {
80 size_t nr;
81 pid_t *entries;
82 } filter_pids;
83 double duration_filter;
84 double runtime_ms;
85 struct {
86 u64 vfs_getname,
87 proc_getname;
88 } stats;
89 unsigned int max_stack;
90 unsigned int min_stack;
91 bool not_ev_qualifier;
92 bool live;
93 bool full_time;
94 bool sched;
95 bool multiple_threads;
96 bool summary;
97 bool summary_only;
98 bool show_comm;
99 bool show_tool_stats;
100 bool trace_syscalls;
101 bool kernel_syscallchains;
102 bool force;
103 bool vfs_getname;
104 int trace_pgfaults;
105 int open_id;
106 };
107
108 struct tp_field {
109 int offset;
110 union {
111 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
112 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
113 };
114 };
115
116 #define TP_UINT_FIELD(bits) \
117 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
118 { \
119 u##bits value; \
120 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
121 return value; \
122 }
123
124 TP_UINT_FIELD(8);
125 TP_UINT_FIELD(16);
126 TP_UINT_FIELD(32);
127 TP_UINT_FIELD(64);
128
129 #define TP_UINT_FIELD__SWAPPED(bits) \
130 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
131 { \
132 u##bits value; \
133 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
134 return bswap_##bits(value);\
135 }
136
137 TP_UINT_FIELD__SWAPPED(16);
138 TP_UINT_FIELD__SWAPPED(32);
139 TP_UINT_FIELD__SWAPPED(64);
140
141 static int tp_field__init_uint(struct tp_field *field,
142 struct format_field *format_field,
143 bool needs_swap)
144 {
145 field->offset = format_field->offset;
146
147 switch (format_field->size) {
148 case 1:
149 field->integer = tp_field__u8;
150 break;
151 case 2:
152 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
153 break;
154 case 4:
155 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
156 break;
157 case 8:
158 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
159 break;
160 default:
161 return -1;
162 }
163
164 return 0;
165 }
166
167 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
168 {
169 return sample->raw_data + field->offset;
170 }
171
172 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
173 {
174 field->offset = format_field->offset;
175 field->pointer = tp_field__ptr;
176 return 0;
177 }
178
179 struct syscall_tp {
180 struct tp_field id;
181 union {
182 struct tp_field args, ret;
183 };
184 };
185
186 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
187 struct tp_field *field,
188 const char *name)
189 {
190 struct format_field *format_field = perf_evsel__field(evsel, name);
191
192 if (format_field == NULL)
193 return -1;
194
195 return tp_field__init_uint(field, format_field, evsel->needs_swap);
196 }
197
198 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
199 ({ struct syscall_tp *sc = evsel->priv;\
200 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
201
202 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
203 struct tp_field *field,
204 const char *name)
205 {
206 struct format_field *format_field = perf_evsel__field(evsel, name);
207
208 if (format_field == NULL)
209 return -1;
210
211 return tp_field__init_ptr(field, format_field);
212 }
213
214 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
215 ({ struct syscall_tp *sc = evsel->priv;\
216 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
217
218 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
219 {
220 zfree(&evsel->priv);
221 perf_evsel__delete(evsel);
222 }
223
224 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
225 {
226 evsel->priv = malloc(sizeof(struct syscall_tp));
227 if (evsel->priv != NULL) {
228 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
229 goto out_delete;
230
231 evsel->handler = handler;
232 return 0;
233 }
234
235 return -ENOMEM;
236
237 out_delete:
238 zfree(&evsel->priv);
239 return -ENOENT;
240 }
241
242 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
243 {
244 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
245
246 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
247 if (IS_ERR(evsel))
248 evsel = perf_evsel__newtp("syscalls", direction);
249
250 if (IS_ERR(evsel))
251 return NULL;
252
253 if (perf_evsel__init_syscall_tp(evsel, handler))
254 goto out_delete;
255
256 return evsel;
257
258 out_delete:
259 perf_evsel__delete_priv(evsel);
260 return NULL;
261 }
262
263 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
264 ({ struct syscall_tp *fields = evsel->priv; \
265 fields->name.integer(&fields->name, sample); })
266
267 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
268 ({ struct syscall_tp *fields = evsel->priv; \
269 fields->name.pointer(&fields->name, sample); })
270
271 struct syscall_arg {
272 unsigned long val;
273 struct thread *thread;
274 struct trace *trace;
275 void *parm;
276 u8 idx;
277 u8 mask;
278 };
279
280 struct strarray {
281 int offset;
282 int nr_entries;
283 const char **entries;
284 };
285
286 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
287 .nr_entries = ARRAY_SIZE(array), \
288 .entries = array, \
289 }
290
291 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
292 .offset = off, \
293 .nr_entries = ARRAY_SIZE(array), \
294 .entries = array, \
295 }
296
297 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
298 const char *intfmt,
299 struct syscall_arg *arg)
300 {
301 struct strarray *sa = arg->parm;
302 int idx = arg->val - sa->offset;
303
304 if (idx < 0 || idx >= sa->nr_entries)
305 return scnprintf(bf, size, intfmt, arg->val);
306
307 return scnprintf(bf, size, "%s", sa->entries[idx]);
308 }
309
310 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
311 struct syscall_arg *arg)
312 {
313 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
314 }
315
316 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
317
318 #if defined(__i386__) || defined(__x86_64__)
319 /*
320 * FIXME: Make this available to all arches as soon as the ioctl beautifier
321 * gets rewritten to support all arches.
322 */
323 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
324 struct syscall_arg *arg)
325 {
326 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
327 }
328
329 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
330 #endif /* defined(__i386__) || defined(__x86_64__) */
331
332 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
333 struct syscall_arg *arg);
334
335 #define SCA_FD syscall_arg__scnprintf_fd
336
337 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
338 struct syscall_arg *arg)
339 {
340 int fd = arg->val;
341
342 if (fd == AT_FDCWD)
343 return scnprintf(bf, size, "CWD");
344
345 return syscall_arg__scnprintf_fd(bf, size, arg);
346 }
347
348 #define SCA_FDAT syscall_arg__scnprintf_fd_at
349
350 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
351 struct syscall_arg *arg);
352
353 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
354
355 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
356 struct syscall_arg *arg)
357 {
358 return scnprintf(bf, size, "%#lx", arg->val);
359 }
360
361 #define SCA_HEX syscall_arg__scnprintf_hex
362
363 static size_t syscall_arg__scnprintf_int(char *bf, size_t size,
364 struct syscall_arg *arg)
365 {
366 return scnprintf(bf, size, "%d", arg->val);
367 }
368
369 #define SCA_INT syscall_arg__scnprintf_int
370
371 static const char *bpf_cmd[] = {
372 "MAP_CREATE", "MAP_LOOKUP_ELEM", "MAP_UPDATE_ELEM", "MAP_DELETE_ELEM",
373 "MAP_GET_NEXT_KEY", "PROG_LOAD",
374 };
375 static DEFINE_STRARRAY(bpf_cmd);
376
377 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
378 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
379
380 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
381 static DEFINE_STRARRAY(itimers);
382
383 static const char *keyctl_options[] = {
384 "GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
385 "SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
386 "INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
387 "ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
388 "INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
389 };
390 static DEFINE_STRARRAY(keyctl_options);
391
392 static const char *whences[] = { "SET", "CUR", "END",
393 #ifdef SEEK_DATA
394 "DATA",
395 #endif
396 #ifdef SEEK_HOLE
397 "HOLE",
398 #endif
399 };
400 static DEFINE_STRARRAY(whences);
401
402 static const char *fcntl_cmds[] = {
403 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
404 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
405 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
406 "F_GETOWNER_UIDS",
407 };
408 static DEFINE_STRARRAY(fcntl_cmds);
409
410 static const char *rlimit_resources[] = {
411 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
412 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
413 "RTTIME",
414 };
415 static DEFINE_STRARRAY(rlimit_resources);
416
417 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
418 static DEFINE_STRARRAY(sighow);
419
420 static const char *clockid[] = {
421 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
422 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
423 "REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
424 };
425 static DEFINE_STRARRAY(clockid);
426
427 static const char *socket_families[] = {
428 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
429 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
430 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
431 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
432 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
433 "ALG", "NFC", "VSOCK",
434 };
435 static DEFINE_STRARRAY(socket_families);
436
437 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
438 struct syscall_arg *arg)
439 {
440 size_t printed = 0;
441 int mode = arg->val;
442
443 if (mode == F_OK) /* 0 */
444 return scnprintf(bf, size, "F");
445 #define P_MODE(n) \
446 if (mode & n##_OK) { \
447 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
448 mode &= ~n##_OK; \
449 }
450
451 P_MODE(R);
452 P_MODE(W);
453 P_MODE(X);
454 #undef P_MODE
455
456 if (mode)
457 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
458
459 return printed;
460 }
461
462 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
463
464 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
465 struct syscall_arg *arg);
466
467 #define SCA_FILENAME syscall_arg__scnprintf_filename
468
469 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
470 struct syscall_arg *arg)
471 {
472 int printed = 0, flags = arg->val;
473
474 #define P_FLAG(n) \
475 if (flags & O_##n) { \
476 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
477 flags &= ~O_##n; \
478 }
479
480 P_FLAG(CLOEXEC);
481 P_FLAG(NONBLOCK);
482 #undef P_FLAG
483
484 if (flags)
485 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
486
487 return printed;
488 }
489
490 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
491
492 #if defined(__i386__) || defined(__x86_64__)
493 /*
494 * FIXME: Make this available to all arches.
495 */
496 #define TCGETS 0x5401
497
498 static const char *tioctls[] = {
499 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
500 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
501 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
502 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
503 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
504 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
505 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
506 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
507 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
508 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
509 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
510 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
511 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
512 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
513 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
514 };
515
516 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
517 #endif /* defined(__i386__) || defined(__x86_64__) */
518
519 #ifndef GRND_NONBLOCK
520 #define GRND_NONBLOCK 0x0001
521 #endif
522 #ifndef GRND_RANDOM
523 #define GRND_RANDOM 0x0002
524 #endif
525
526 static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
527 struct syscall_arg *arg)
528 {
529 int printed = 0, flags = arg->val;
530
531 #define P_FLAG(n) \
532 if (flags & GRND_##n) { \
533 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
534 flags &= ~GRND_##n; \
535 }
536
537 P_FLAG(RANDOM);
538 P_FLAG(NONBLOCK);
539 #undef P_FLAG
540
541 if (flags)
542 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
543
544 return printed;
545 }
546
547 #define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
548
549 #define STRARRAY(arg, name, array) \
550 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
551 .arg_parm = { [arg] = &strarray__##array, }
552
553 #include "trace/beauty/eventfd.c"
554 #include "trace/beauty/flock.c"
555 #include "trace/beauty/futex_op.c"
556 #include "trace/beauty/mmap.c"
557 #include "trace/beauty/mode_t.c"
558 #include "trace/beauty/msg_flags.c"
559 #include "trace/beauty/open_flags.c"
560 #include "trace/beauty/perf_event_open.c"
561 #include "trace/beauty/pid.c"
562 #include "trace/beauty/sched_policy.c"
563 #include "trace/beauty/seccomp.c"
564 #include "trace/beauty/signum.c"
565 #include "trace/beauty/socket_type.c"
566 #include "trace/beauty/waitid_options.c"
567
568 static struct syscall_fmt {
569 const char *name;
570 const char *alias;
571 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
572 void *arg_parm[6];
573 bool errmsg;
574 bool errpid;
575 bool timeout;
576 bool hexret;
577 } syscall_fmts[] = {
578 { .name = "access", .errmsg = true,
579 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */
580 [1] = SCA_ACCMODE, /* mode */ }, },
581 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
582 { .name = "bpf", .errmsg = true, STRARRAY(0, cmd, bpf_cmd), },
583 { .name = "brk", .hexret = true,
584 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
585 { .name = "chdir", .errmsg = true,
586 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
587 { .name = "chmod", .errmsg = true,
588 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
589 { .name = "chroot", .errmsg = true,
590 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
591 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
592 { .name = "clone", .errpid = true, },
593 { .name = "close", .errmsg = true,
594 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
595 { .name = "connect", .errmsg = true, },
596 { .name = "creat", .errmsg = true,
597 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
598 { .name = "dup", .errmsg = true,
599 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
600 { .name = "dup2", .errmsg = true,
601 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
602 { .name = "dup3", .errmsg = true,
603 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
604 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
605 { .name = "eventfd2", .errmsg = true,
606 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
607 { .name = "faccessat", .errmsg = true,
608 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
609 [1] = SCA_FILENAME, /* filename */ }, },
610 { .name = "fadvise64", .errmsg = true,
611 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
612 { .name = "fallocate", .errmsg = true,
613 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
614 { .name = "fchdir", .errmsg = true,
615 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
616 { .name = "fchmod", .errmsg = true,
617 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
618 { .name = "fchmodat", .errmsg = true,
619 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
620 [1] = SCA_FILENAME, /* filename */ }, },
621 { .name = "fchown", .errmsg = true,
622 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
623 { .name = "fchownat", .errmsg = true,
624 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
625 [1] = SCA_FILENAME, /* filename */ }, },
626 { .name = "fcntl", .errmsg = true,
627 .arg_scnprintf = { [0] = SCA_FD, /* fd */
628 [1] = SCA_STRARRAY, /* cmd */ },
629 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
630 { .name = "fdatasync", .errmsg = true,
631 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
632 { .name = "flock", .errmsg = true,
633 .arg_scnprintf = { [0] = SCA_FD, /* fd */
634 [1] = SCA_FLOCK, /* cmd */ }, },
635 { .name = "fsetxattr", .errmsg = true,
636 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
637 { .name = "fstat", .errmsg = true, .alias = "newfstat",
638 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
639 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
640 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
641 [1] = SCA_FILENAME, /* filename */ }, },
642 { .name = "fstatfs", .errmsg = true,
643 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
644 { .name = "fsync", .errmsg = true,
645 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
646 { .name = "ftruncate", .errmsg = true,
647 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
648 { .name = "futex", .errmsg = true,
649 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
650 { .name = "futimesat", .errmsg = true,
651 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
652 [1] = SCA_FILENAME, /* filename */ }, },
653 { .name = "getdents", .errmsg = true,
654 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
655 { .name = "getdents64", .errmsg = true,
656 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
657 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
658 { .name = "getpid", .errpid = true, },
659 { .name = "getpgid", .errpid = true, },
660 { .name = "getppid", .errpid = true, },
661 { .name = "getrandom", .errmsg = true,
662 .arg_scnprintf = { [2] = SCA_GETRANDOM_FLAGS, /* flags */ }, },
663 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
664 { .name = "getxattr", .errmsg = true,
665 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
666 { .name = "inotify_add_watch", .errmsg = true,
667 .arg_scnprintf = { [1] = SCA_FILENAME, /* pathname */ }, },
668 { .name = "ioctl", .errmsg = true,
669 .arg_scnprintf = { [0] = SCA_FD, /* fd */
670 #if defined(__i386__) || defined(__x86_64__)
671 /*
672 * FIXME: Make this available to all arches.
673 */
674 [1] = SCA_STRHEXARRAY, /* cmd */
675 [2] = SCA_HEX, /* arg */ },
676 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
677 #else
678 [2] = SCA_HEX, /* arg */ }, },
679 #endif
680 { .name = "keyctl", .errmsg = true, STRARRAY(0, option, keyctl_options), },
681 { .name = "kill", .errmsg = true,
682 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
683 { .name = "lchown", .errmsg = true,
684 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
685 { .name = "lgetxattr", .errmsg = true,
686 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
687 { .name = "linkat", .errmsg = true,
688 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
689 { .name = "listxattr", .errmsg = true,
690 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
691 { .name = "llistxattr", .errmsg = true,
692 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
693 { .name = "lremovexattr", .errmsg = true,
694 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
695 { .name = "lseek", .errmsg = true,
696 .arg_scnprintf = { [0] = SCA_FD, /* fd */
697 [2] = SCA_STRARRAY, /* whence */ },
698 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
699 { .name = "lsetxattr", .errmsg = true,
700 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
701 { .name = "lstat", .errmsg = true, .alias = "newlstat",
702 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
703 { .name = "lsxattr", .errmsg = true,
704 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
705 { .name = "madvise", .errmsg = true,
706 .arg_scnprintf = { [0] = SCA_HEX, /* start */
707 [2] = SCA_MADV_BHV, /* behavior */ }, },
708 { .name = "mkdir", .errmsg = true,
709 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
710 { .name = "mkdirat", .errmsg = true,
711 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
712 [1] = SCA_FILENAME, /* pathname */ }, },
713 { .name = "mknod", .errmsg = true,
714 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
715 { .name = "mknodat", .errmsg = true,
716 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
717 [1] = SCA_FILENAME, /* filename */ }, },
718 { .name = "mlock", .errmsg = true,
719 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
720 { .name = "mlockall", .errmsg = true,
721 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
722 { .name = "mmap", .hexret = true,
723 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
724 [2] = SCA_MMAP_PROT, /* prot */
725 [3] = SCA_MMAP_FLAGS, /* flags */
726 [4] = SCA_FD, /* fd */ }, },
727 { .name = "mprotect", .errmsg = true,
728 .arg_scnprintf = { [0] = SCA_HEX, /* start */
729 [2] = SCA_MMAP_PROT, /* prot */ }, },
730 { .name = "mq_unlink", .errmsg = true,
731 .arg_scnprintf = { [0] = SCA_FILENAME, /* u_name */ }, },
732 { .name = "mremap", .hexret = true,
733 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
734 [3] = SCA_MREMAP_FLAGS, /* flags */
735 [4] = SCA_HEX, /* new_addr */ }, },
736 { .name = "munlock", .errmsg = true,
737 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
738 { .name = "munmap", .errmsg = true,
739 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
740 { .name = "name_to_handle_at", .errmsg = true,
741 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
742 { .name = "newfstatat", .errmsg = true,
743 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
744 [1] = SCA_FILENAME, /* filename */ }, },
745 { .name = "open", .errmsg = true,
746 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */
747 [1] = SCA_OPEN_FLAGS, /* flags */ }, },
748 { .name = "open_by_handle_at", .errmsg = true,
749 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
750 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
751 { .name = "openat", .errmsg = true,
752 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
753 [1] = SCA_FILENAME, /* filename */
754 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
755 { .name = "perf_event_open", .errmsg = true,
756 .arg_scnprintf = { [2] = SCA_INT, /* cpu */
757 [3] = SCA_FD, /* group_fd */
758 [4] = SCA_PERF_FLAGS, /* flags */ }, },
759 { .name = "pipe2", .errmsg = true,
760 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
761 { .name = "poll", .errmsg = true, .timeout = true, },
762 { .name = "ppoll", .errmsg = true, .timeout = true, },
763 { .name = "pread", .errmsg = true, .alias = "pread64",
764 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
765 { .name = "preadv", .errmsg = true, .alias = "pread",
766 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
767 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
768 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
769 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
770 { .name = "pwritev", .errmsg = true,
771 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
772 { .name = "read", .errmsg = true,
773 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
774 { .name = "readlink", .errmsg = true,
775 .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
776 { .name = "readlinkat", .errmsg = true,
777 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
778 [1] = SCA_FILENAME, /* pathname */ }, },
779 { .name = "readv", .errmsg = true,
780 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
781 { .name = "recvfrom", .errmsg = true,
782 .arg_scnprintf = { [0] = SCA_FD, /* fd */
783 [3] = SCA_MSG_FLAGS, /* flags */ }, },
784 { .name = "recvmmsg", .errmsg = true,
785 .arg_scnprintf = { [0] = SCA_FD, /* fd */
786 [3] = SCA_MSG_FLAGS, /* flags */ }, },
787 { .name = "recvmsg", .errmsg = true,
788 .arg_scnprintf = { [0] = SCA_FD, /* fd */
789 [2] = SCA_MSG_FLAGS, /* flags */ }, },
790 { .name = "removexattr", .errmsg = true,
791 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
792 { .name = "renameat", .errmsg = true,
793 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
794 { .name = "rmdir", .errmsg = true,
795 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
796 { .name = "rt_sigaction", .errmsg = true,
797 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
798 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
799 { .name = "rt_sigqueueinfo", .errmsg = true,
800 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
801 { .name = "rt_tgsigqueueinfo", .errmsg = true,
802 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
803 { .name = "sched_setscheduler", .errmsg = true,
804 .arg_scnprintf = { [1] = SCA_SCHED_POLICY, /* policy */ }, },
805 { .name = "seccomp", .errmsg = true,
806 .arg_scnprintf = { [0] = SCA_SECCOMP_OP, /* op */
807 [1] = SCA_SECCOMP_FLAGS, /* flags */ }, },
808 { .name = "select", .errmsg = true, .timeout = true, },
809 { .name = "sendmmsg", .errmsg = true,
810 .arg_scnprintf = { [0] = SCA_FD, /* fd */
811 [3] = SCA_MSG_FLAGS, /* flags */ }, },
812 { .name = "sendmsg", .errmsg = true,
813 .arg_scnprintf = { [0] = SCA_FD, /* fd */
814 [2] = SCA_MSG_FLAGS, /* flags */ }, },
815 { .name = "sendto", .errmsg = true,
816 .arg_scnprintf = { [0] = SCA_FD, /* fd */
817 [3] = SCA_MSG_FLAGS, /* flags */ }, },
818 { .name = "set_tid_address", .errpid = true, },
819 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
820 { .name = "setpgid", .errmsg = true, },
821 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
822 { .name = "setxattr", .errmsg = true,
823 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
824 { .name = "shutdown", .errmsg = true,
825 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
826 { .name = "socket", .errmsg = true,
827 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
828 [1] = SCA_SK_TYPE, /* type */ },
829 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
830 { .name = "socketpair", .errmsg = true,
831 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
832 [1] = SCA_SK_TYPE, /* type */ },
833 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
834 { .name = "stat", .errmsg = true, .alias = "newstat",
835 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
836 { .name = "statfs", .errmsg = true,
837 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
838 { .name = "swapoff", .errmsg = true,
839 .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
840 { .name = "swapon", .errmsg = true,
841 .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
842 { .name = "symlinkat", .errmsg = true,
843 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
844 { .name = "tgkill", .errmsg = true,
845 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
846 { .name = "tkill", .errmsg = true,
847 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
848 { .name = "truncate", .errmsg = true,
849 .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
850 { .name = "uname", .errmsg = true, .alias = "newuname", },
851 { .name = "unlinkat", .errmsg = true,
852 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
853 [1] = SCA_FILENAME, /* pathname */ }, },
854 { .name = "utime", .errmsg = true,
855 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
856 { .name = "utimensat", .errmsg = true,
857 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */
858 [1] = SCA_FILENAME, /* filename */ }, },
859 { .name = "utimes", .errmsg = true,
860 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
861 { .name = "vmsplice", .errmsg = true,
862 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
863 { .name = "wait4", .errpid = true,
864 .arg_scnprintf = { [2] = SCA_WAITID_OPTIONS, /* options */ }, },
865 { .name = "waitid", .errpid = true,
866 .arg_scnprintf = { [3] = SCA_WAITID_OPTIONS, /* options */ }, },
867 { .name = "write", .errmsg = true,
868 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
869 { .name = "writev", .errmsg = true,
870 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
871 };
872
873 static int syscall_fmt__cmp(const void *name, const void *fmtp)
874 {
875 const struct syscall_fmt *fmt = fmtp;
876 return strcmp(name, fmt->name);
877 }
878
879 static struct syscall_fmt *syscall_fmt__find(const char *name)
880 {
881 const int nmemb = ARRAY_SIZE(syscall_fmts);
882 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
883 }
884
885 struct syscall {
886 struct event_format *tp_format;
887 int nr_args;
888 struct format_field *args;
889 const char *name;
890 bool is_exit;
891 struct syscall_fmt *fmt;
892 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
893 void **arg_parm;
894 };
895
896 static size_t fprintf_duration(unsigned long t, FILE *fp)
897 {
898 double duration = (double)t / NSEC_PER_MSEC;
899 size_t printed = fprintf(fp, "(");
900
901 if (duration >= 1.0)
902 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
903 else if (duration >= 0.01)
904 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
905 else
906 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
907 return printed + fprintf(fp, "): ");
908 }
909
910 /**
911 * filename.ptr: The filename char pointer that will be vfs_getname'd
912 * filename.entry_str_pos: Where to insert the string translated from
913 * filename.ptr by the vfs_getname tracepoint/kprobe.
914 */
915 struct thread_trace {
916 u64 entry_time;
917 u64 exit_time;
918 bool entry_pending;
919 unsigned long nr_events;
920 unsigned long pfmaj, pfmin;
921 char *entry_str;
922 double runtime_ms;
923 struct {
924 unsigned long ptr;
925 short int entry_str_pos;
926 bool pending_open;
927 unsigned int namelen;
928 char *name;
929 } filename;
930 struct {
931 int max;
932 char **table;
933 } paths;
934
935 struct intlist *syscall_stats;
936 };
937
938 static struct thread_trace *thread_trace__new(void)
939 {
940 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
941
942 if (ttrace)
943 ttrace->paths.max = -1;
944
945 ttrace->syscall_stats = intlist__new(NULL);
946
947 return ttrace;
948 }
949
950 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
951 {
952 struct thread_trace *ttrace;
953
954 if (thread == NULL)
955 goto fail;
956
957 if (thread__priv(thread) == NULL)
958 thread__set_priv(thread, thread_trace__new());
959
960 if (thread__priv(thread) == NULL)
961 goto fail;
962
963 ttrace = thread__priv(thread);
964 ++ttrace->nr_events;
965
966 return ttrace;
967 fail:
968 color_fprintf(fp, PERF_COLOR_RED,
969 "WARNING: not enough memory, dropping samples!\n");
970 return NULL;
971 }
972
973 #define TRACE_PFMAJ (1 << 0)
974 #define TRACE_PFMIN (1 << 1)
975
976 static const size_t trace__entry_str_size = 2048;
977
978 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
979 {
980 struct thread_trace *ttrace = thread__priv(thread);
981
982 if (fd > ttrace->paths.max) {
983 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
984
985 if (npath == NULL)
986 return -1;
987
988 if (ttrace->paths.max != -1) {
989 memset(npath + ttrace->paths.max + 1, 0,
990 (fd - ttrace->paths.max) * sizeof(char *));
991 } else {
992 memset(npath, 0, (fd + 1) * sizeof(char *));
993 }
994
995 ttrace->paths.table = npath;
996 ttrace->paths.max = fd;
997 }
998
999 ttrace->paths.table[fd] = strdup(pathname);
1000
1001 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1002 }
1003
1004 static int thread__read_fd_path(struct thread *thread, int fd)
1005 {
1006 char linkname[PATH_MAX], pathname[PATH_MAX];
1007 struct stat st;
1008 int ret;
1009
1010 if (thread->pid_ == thread->tid) {
1011 scnprintf(linkname, sizeof(linkname),
1012 "/proc/%d/fd/%d", thread->pid_, fd);
1013 } else {
1014 scnprintf(linkname, sizeof(linkname),
1015 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1016 }
1017
1018 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1019 return -1;
1020
1021 ret = readlink(linkname, pathname, sizeof(pathname));
1022
1023 if (ret < 0 || ret > st.st_size)
1024 return -1;
1025
1026 pathname[ret] = '\0';
1027 return trace__set_fd_pathname(thread, fd, pathname);
1028 }
1029
1030 static const char *thread__fd_path(struct thread *thread, int fd,
1031 struct trace *trace)
1032 {
1033 struct thread_trace *ttrace = thread__priv(thread);
1034
1035 if (ttrace == NULL)
1036 return NULL;
1037
1038 if (fd < 0)
1039 return NULL;
1040
1041 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1042 if (!trace->live)
1043 return NULL;
1044 ++trace->stats.proc_getname;
1045 if (thread__read_fd_path(thread, fd))
1046 return NULL;
1047 }
1048
1049 return ttrace->paths.table[fd];
1050 }
1051
1052 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1053 struct syscall_arg *arg)
1054 {
1055 int fd = arg->val;
1056 size_t printed = scnprintf(bf, size, "%d", fd);
1057 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1058
1059 if (path)
1060 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1061
1062 return printed;
1063 }
1064
1065 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1066 struct syscall_arg *arg)
1067 {
1068 int fd = arg->val;
1069 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1070 struct thread_trace *ttrace = thread__priv(arg->thread);
1071
1072 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1073 zfree(&ttrace->paths.table[fd]);
1074
1075 return printed;
1076 }
1077
1078 static void thread__set_filename_pos(struct thread *thread, const char *bf,
1079 unsigned long ptr)
1080 {
1081 struct thread_trace *ttrace = thread__priv(thread);
1082
1083 ttrace->filename.ptr = ptr;
1084 ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1085 }
1086
1087 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1088 struct syscall_arg *arg)
1089 {
1090 unsigned long ptr = arg->val;
1091
1092 if (!arg->trace->vfs_getname)
1093 return scnprintf(bf, size, "%#x", ptr);
1094
1095 thread__set_filename_pos(arg->thread, bf, ptr);
1096 return 0;
1097 }
1098
1099 static bool trace__filter_duration(struct trace *trace, double t)
1100 {
1101 return t < (trace->duration_filter * NSEC_PER_MSEC);
1102 }
1103
1104 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1105 {
1106 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1107
1108 return fprintf(fp, "%10.3f ", ts);
1109 }
1110
1111 static bool done = false;
1112 static bool interrupted = false;
1113
1114 static void sig_handler(int sig)
1115 {
1116 done = true;
1117 interrupted = sig == SIGINT;
1118 }
1119
1120 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1121 u64 duration, u64 tstamp, FILE *fp)
1122 {
1123 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1124 printed += fprintf_duration(duration, fp);
1125
1126 if (trace->multiple_threads) {
1127 if (trace->show_comm)
1128 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1129 printed += fprintf(fp, "%d ", thread->tid);
1130 }
1131
1132 return printed;
1133 }
1134
1135 static int trace__process_event(struct trace *trace, struct machine *machine,
1136 union perf_event *event, struct perf_sample *sample)
1137 {
1138 int ret = 0;
1139
1140 switch (event->header.type) {
1141 case PERF_RECORD_LOST:
1142 color_fprintf(trace->output, PERF_COLOR_RED,
1143 "LOST %" PRIu64 " events!\n", event->lost.lost);
1144 ret = machine__process_lost_event(machine, event, sample);
1145 break;
1146 default:
1147 ret = machine__process_event(machine, event, sample);
1148 break;
1149 }
1150
1151 return ret;
1152 }
1153
1154 static int trace__tool_process(struct perf_tool *tool,
1155 union perf_event *event,
1156 struct perf_sample *sample,
1157 struct machine *machine)
1158 {
1159 struct trace *trace = container_of(tool, struct trace, tool);
1160 return trace__process_event(trace, machine, event, sample);
1161 }
1162
1163 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1164 {
1165 int err = symbol__init(NULL);
1166
1167 if (err)
1168 return err;
1169
1170 trace->host = machine__new_host();
1171 if (trace->host == NULL)
1172 return -ENOMEM;
1173
1174 if (trace_event__register_resolver(trace->host, machine__resolve_kernel_addr) < 0)
1175 return -errno;
1176
1177 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1178 evlist->threads, trace__tool_process, false,
1179 trace->opts.proc_map_timeout);
1180 if (err)
1181 symbol__exit();
1182
1183 return err;
1184 }
1185
1186 static int syscall__set_arg_fmts(struct syscall *sc)
1187 {
1188 struct format_field *field;
1189 int idx = 0;
1190
1191 sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
1192 if (sc->arg_scnprintf == NULL)
1193 return -1;
1194
1195 if (sc->fmt)
1196 sc->arg_parm = sc->fmt->arg_parm;
1197
1198 for (field = sc->args; field; field = field->next) {
1199 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1200 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1201 else if (field->flags & FIELD_IS_POINTER)
1202 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1203 else if (strcmp(field->type, "pid_t") == 0)
1204 sc->arg_scnprintf[idx] = SCA_PID;
1205 else if (strcmp(field->type, "umode_t") == 0)
1206 sc->arg_scnprintf[idx] = SCA_MODE_T;
1207 ++idx;
1208 }
1209
1210 return 0;
1211 }
1212
1213 static int trace__read_syscall_info(struct trace *trace, int id)
1214 {
1215 char tp_name[128];
1216 struct syscall *sc;
1217 const char *name = syscalltbl__name(trace->sctbl, id);
1218
1219 if (name == NULL)
1220 return -1;
1221
1222 if (id > trace->syscalls.max) {
1223 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1224
1225 if (nsyscalls == NULL)
1226 return -1;
1227
1228 if (trace->syscalls.max != -1) {
1229 memset(nsyscalls + trace->syscalls.max + 1, 0,
1230 (id - trace->syscalls.max) * sizeof(*sc));
1231 } else {
1232 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1233 }
1234
1235 trace->syscalls.table = nsyscalls;
1236 trace->syscalls.max = id;
1237 }
1238
1239 sc = trace->syscalls.table + id;
1240 sc->name = name;
1241
1242 sc->fmt = syscall_fmt__find(sc->name);
1243
1244 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1245 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1246
1247 if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
1248 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1249 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1250 }
1251
1252 if (IS_ERR(sc->tp_format))
1253 return -1;
1254
1255 sc->args = sc->tp_format->format.fields;
1256 sc->nr_args = sc->tp_format->format.nr_fields;
1257 /*
1258 * We need to check and discard the first variable '__syscall_nr'
1259 * or 'nr' that mean the syscall number. It is needless here.
1260 * So drop '__syscall_nr' or 'nr' field but does not exist on older kernels.
1261 */
1262 if (sc->args && (!strcmp(sc->args->name, "__syscall_nr") || !strcmp(sc->args->name, "nr"))) {
1263 sc->args = sc->args->next;
1264 --sc->nr_args;
1265 }
1266
1267 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1268
1269 return syscall__set_arg_fmts(sc);
1270 }
1271
1272 static int trace__validate_ev_qualifier(struct trace *trace)
1273 {
1274 int err = 0, i;
1275 struct str_node *pos;
1276
1277 trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1278 trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1279 sizeof(trace->ev_qualifier_ids.entries[0]));
1280
1281 if (trace->ev_qualifier_ids.entries == NULL) {
1282 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1283 trace->output);
1284 err = -EINVAL;
1285 goto out;
1286 }
1287
1288 i = 0;
1289
1290 strlist__for_each(pos, trace->ev_qualifier) {
1291 const char *sc = pos->s;
1292 int id = syscalltbl__id(trace->sctbl, sc);
1293
1294 if (id < 0) {
1295 if (err == 0) {
1296 fputs("Error:\tInvalid syscall ", trace->output);
1297 err = -EINVAL;
1298 } else {
1299 fputs(", ", trace->output);
1300 }
1301
1302 fputs(sc, trace->output);
1303 }
1304
1305 trace->ev_qualifier_ids.entries[i++] = id;
1306 }
1307
1308 if (err < 0) {
1309 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1310 "\nHint:\tand: 'man syscalls'\n", trace->output);
1311 zfree(&trace->ev_qualifier_ids.entries);
1312 trace->ev_qualifier_ids.nr = 0;
1313 }
1314 out:
1315 return err;
1316 }
1317
1318 /*
1319 * args is to be interpreted as a series of longs but we need to handle
1320 * 8-byte unaligned accesses. args points to raw_data within the event
1321 * and raw_data is guaranteed to be 8-byte unaligned because it is
1322 * preceded by raw_size which is a u32. So we need to copy args to a temp
1323 * variable to read it. Most notably this avoids extended load instructions
1324 * on unaligned addresses
1325 */
1326
1327 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1328 unsigned char *args, struct trace *trace,
1329 struct thread *thread)
1330 {
1331 size_t printed = 0;
1332 unsigned char *p;
1333 unsigned long val;
1334
1335 if (sc->args != NULL) {
1336 struct format_field *field;
1337 u8 bit = 1;
1338 struct syscall_arg arg = {
1339 .idx = 0,
1340 .mask = 0,
1341 .trace = trace,
1342 .thread = thread,
1343 };
1344
1345 for (field = sc->args; field;
1346 field = field->next, ++arg.idx, bit <<= 1) {
1347 if (arg.mask & bit)
1348 continue;
1349
1350 /* special care for unaligned accesses */
1351 p = args + sizeof(unsigned long) * arg.idx;
1352 memcpy(&val, p, sizeof(val));
1353
1354 /*
1355 * Suppress this argument if its value is zero and
1356 * and we don't have a string associated in an
1357 * strarray for it.
1358 */
1359 if (val == 0 &&
1360 !(sc->arg_scnprintf &&
1361 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1362 sc->arg_parm[arg.idx]))
1363 continue;
1364
1365 printed += scnprintf(bf + printed, size - printed,
1366 "%s%s: ", printed ? ", " : "", field->name);
1367 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1368 arg.val = val;
1369 if (sc->arg_parm)
1370 arg.parm = sc->arg_parm[arg.idx];
1371 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1372 size - printed, &arg);
1373 } else {
1374 printed += scnprintf(bf + printed, size - printed,
1375 "%ld", val);
1376 }
1377 }
1378 } else if (IS_ERR(sc->tp_format)) {
1379 /*
1380 * If we managed to read the tracepoint /format file, then we
1381 * may end up not having any args, like with gettid(), so only
1382 * print the raw args when we didn't manage to read it.
1383 */
1384 int i = 0;
1385
1386 while (i < 6) {
1387 /* special care for unaligned accesses */
1388 p = args + sizeof(unsigned long) * i;
1389 memcpy(&val, p, sizeof(val));
1390 printed += scnprintf(bf + printed, size - printed,
1391 "%sarg%d: %ld",
1392 printed ? ", " : "", i, val);
1393 ++i;
1394 }
1395 }
1396
1397 return printed;
1398 }
1399
1400 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1401 union perf_event *event,
1402 struct perf_sample *sample);
1403
1404 static struct syscall *trace__syscall_info(struct trace *trace,
1405 struct perf_evsel *evsel, int id)
1406 {
1407
1408 if (id < 0) {
1409
1410 /*
1411 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1412 * before that, leaving at a higher verbosity level till that is
1413 * explained. Reproduced with plain ftrace with:
1414 *
1415 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1416 * grep "NR -1 " /t/trace_pipe
1417 *
1418 * After generating some load on the machine.
1419 */
1420 if (verbose > 1) {
1421 static u64 n;
1422 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1423 id, perf_evsel__name(evsel), ++n);
1424 }
1425 return NULL;
1426 }
1427
1428 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1429 trace__read_syscall_info(trace, id))
1430 goto out_cant_read;
1431
1432 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1433 goto out_cant_read;
1434
1435 return &trace->syscalls.table[id];
1436
1437 out_cant_read:
1438 if (verbose) {
1439 fprintf(trace->output, "Problems reading syscall %d", id);
1440 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1441 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1442 fputs(" information\n", trace->output);
1443 }
1444 return NULL;
1445 }
1446
1447 static void thread__update_stats(struct thread_trace *ttrace,
1448 int id, struct perf_sample *sample)
1449 {
1450 struct int_node *inode;
1451 struct stats *stats;
1452 u64 duration = 0;
1453
1454 inode = intlist__findnew(ttrace->syscall_stats, id);
1455 if (inode == NULL)
1456 return;
1457
1458 stats = inode->priv;
1459 if (stats == NULL) {
1460 stats = malloc(sizeof(struct stats));
1461 if (stats == NULL)
1462 return;
1463 init_stats(stats);
1464 inode->priv = stats;
1465 }
1466
1467 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1468 duration = sample->time - ttrace->entry_time;
1469
1470 update_stats(stats, duration);
1471 }
1472
1473 static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1474 {
1475 struct thread_trace *ttrace;
1476 u64 duration;
1477 size_t printed;
1478
1479 if (trace->current == NULL)
1480 return 0;
1481
1482 ttrace = thread__priv(trace->current);
1483
1484 if (!ttrace->entry_pending)
1485 return 0;
1486
1487 duration = sample->time - ttrace->entry_time;
1488
1489 printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1490 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1491 ttrace->entry_pending = false;
1492
1493 return printed;
1494 }
1495
1496 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1497 union perf_event *event __maybe_unused,
1498 struct perf_sample *sample)
1499 {
1500 char *msg;
1501 void *args;
1502 size_t printed = 0;
1503 struct thread *thread;
1504 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1505 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1506 struct thread_trace *ttrace;
1507
1508 if (sc == NULL)
1509 return -1;
1510
1511 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1512 ttrace = thread__trace(thread, trace->output);
1513 if (ttrace == NULL)
1514 goto out_put;
1515
1516 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1517
1518 if (ttrace->entry_str == NULL) {
1519 ttrace->entry_str = malloc(trace__entry_str_size);
1520 if (!ttrace->entry_str)
1521 goto out_put;
1522 }
1523
1524 if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
1525 trace__printf_interrupted_entry(trace, sample);
1526
1527 ttrace->entry_time = sample->time;
1528 msg = ttrace->entry_str;
1529 printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
1530
1531 printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
1532 args, trace, thread);
1533
1534 if (sc->is_exit) {
1535 if (!(trace->duration_filter || trace->summary_only || trace->min_stack)) {
1536 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1537 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1538 }
1539 } else {
1540 ttrace->entry_pending = true;
1541 /* See trace__vfs_getname & trace__sys_exit */
1542 ttrace->filename.pending_open = false;
1543 }
1544
1545 if (trace->current != thread) {
1546 thread__put(trace->current);
1547 trace->current = thread__get(thread);
1548 }
1549 err = 0;
1550 out_put:
1551 thread__put(thread);
1552 return err;
1553 }
1554
1555 static int trace__resolve_callchain(struct trace *trace, struct perf_evsel *evsel,
1556 struct perf_sample *sample,
1557 struct callchain_cursor *cursor)
1558 {
1559 struct addr_location al;
1560
1561 if (machine__resolve(trace->host, &al, sample) < 0 ||
1562 thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, trace->max_stack))
1563 return -1;
1564
1565 return 0;
1566 }
1567
1568 static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
1569 {
1570 /* TODO: user-configurable print_opts */
1571 const unsigned int print_opts = EVSEL__PRINT_SYM |
1572 EVSEL__PRINT_DSO |
1573 EVSEL__PRINT_UNKNOWN_AS_ADDR;
1574
1575 return sample__fprintf_callchain(sample, 38, print_opts, &callchain_cursor, trace->output);
1576 }
1577
1578 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1579 union perf_event *event __maybe_unused,
1580 struct perf_sample *sample)
1581 {
1582 long ret;
1583 u64 duration = 0;
1584 struct thread *thread;
1585 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0;
1586 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1587 struct thread_trace *ttrace;
1588
1589 if (sc == NULL)
1590 return -1;
1591
1592 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1593 ttrace = thread__trace(thread, trace->output);
1594 if (ttrace == NULL)
1595 goto out_put;
1596
1597 if (trace->summary)
1598 thread__update_stats(ttrace, id, sample);
1599
1600 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1601
1602 if (id == trace->open_id && ret >= 0 && ttrace->filename.pending_open) {
1603 trace__set_fd_pathname(thread, ret, ttrace->filename.name);
1604 ttrace->filename.pending_open = false;
1605 ++trace->stats.vfs_getname;
1606 }
1607
1608 ttrace->exit_time = sample->time;
1609
1610 if (ttrace->entry_time) {
1611 duration = sample->time - ttrace->entry_time;
1612 if (trace__filter_duration(trace, duration))
1613 goto out;
1614 } else if (trace->duration_filter)
1615 goto out;
1616
1617 if (sample->callchain) {
1618 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1619 if (callchain_ret == 0) {
1620 if (callchain_cursor.nr < trace->min_stack)
1621 goto out;
1622 callchain_ret = 1;
1623 }
1624 }
1625
1626 if (trace->summary_only)
1627 goto out;
1628
1629 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1630
1631 if (ttrace->entry_pending) {
1632 fprintf(trace->output, "%-70s", ttrace->entry_str);
1633 } else {
1634 fprintf(trace->output, " ... [");
1635 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1636 fprintf(trace->output, "]: %s()", sc->name);
1637 }
1638
1639 if (sc->fmt == NULL) {
1640 signed_print:
1641 fprintf(trace->output, ") = %ld", ret);
1642 } else if (ret < 0 && (sc->fmt->errmsg || sc->fmt->errpid)) {
1643 char bf[STRERR_BUFSIZE];
1644 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1645 *e = audit_errno_to_name(-ret);
1646
1647 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1648 } else if (ret == 0 && sc->fmt->timeout)
1649 fprintf(trace->output, ") = 0 Timeout");
1650 else if (sc->fmt->hexret)
1651 fprintf(trace->output, ") = %#lx", ret);
1652 else if (sc->fmt->errpid) {
1653 struct thread *child = machine__find_thread(trace->host, ret, ret);
1654
1655 if (child != NULL) {
1656 fprintf(trace->output, ") = %ld", ret);
1657 if (child->comm_set)
1658 fprintf(trace->output, " (%s)", thread__comm_str(child));
1659 thread__put(child);
1660 }
1661 } else
1662 goto signed_print;
1663
1664 fputc('\n', trace->output);
1665
1666 if (callchain_ret > 0)
1667 trace__fprintf_callchain(trace, sample);
1668 else if (callchain_ret < 0)
1669 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1670 out:
1671 ttrace->entry_pending = false;
1672 err = 0;
1673 out_put:
1674 thread__put(thread);
1675 return err;
1676 }
1677
1678 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1679 union perf_event *event __maybe_unused,
1680 struct perf_sample *sample)
1681 {
1682 struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1683 struct thread_trace *ttrace;
1684 size_t filename_len, entry_str_len, to_move;
1685 ssize_t remaining_space;
1686 char *pos;
1687 const char *filename = perf_evsel__rawptr(evsel, sample, "pathname");
1688
1689 if (!thread)
1690 goto out;
1691
1692 ttrace = thread__priv(thread);
1693 if (!ttrace)
1694 goto out;
1695
1696 filename_len = strlen(filename);
1697
1698 if (ttrace->filename.namelen < filename_len) {
1699 char *f = realloc(ttrace->filename.name, filename_len + 1);
1700
1701 if (f == NULL)
1702 goto out;
1703
1704 ttrace->filename.namelen = filename_len;
1705 ttrace->filename.name = f;
1706 }
1707
1708 strcpy(ttrace->filename.name, filename);
1709 ttrace->filename.pending_open = true;
1710
1711 if (!ttrace->filename.ptr)
1712 goto out;
1713
1714 entry_str_len = strlen(ttrace->entry_str);
1715 remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
1716 if (remaining_space <= 0)
1717 goto out;
1718
1719 if (filename_len > (size_t)remaining_space) {
1720 filename += filename_len - remaining_space;
1721 filename_len = remaining_space;
1722 }
1723
1724 to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
1725 pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
1726 memmove(pos + filename_len, pos, to_move);
1727 memcpy(pos, filename, filename_len);
1728
1729 ttrace->filename.ptr = 0;
1730 ttrace->filename.entry_str_pos = 0;
1731 out:
1732 return 0;
1733 }
1734
1735 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1736 union perf_event *event __maybe_unused,
1737 struct perf_sample *sample)
1738 {
1739 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1740 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1741 struct thread *thread = machine__findnew_thread(trace->host,
1742 sample->pid,
1743 sample->tid);
1744 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1745
1746 if (ttrace == NULL)
1747 goto out_dump;
1748
1749 ttrace->runtime_ms += runtime_ms;
1750 trace->runtime_ms += runtime_ms;
1751 thread__put(thread);
1752 return 0;
1753
1754 out_dump:
1755 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1756 evsel->name,
1757 perf_evsel__strval(evsel, sample, "comm"),
1758 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1759 runtime,
1760 perf_evsel__intval(evsel, sample, "vruntime"));
1761 thread__put(thread);
1762 return 0;
1763 }
1764
1765 static void bpf_output__printer(enum binary_printer_ops op,
1766 unsigned int val, void *extra)
1767 {
1768 FILE *output = extra;
1769 unsigned char ch = (unsigned char)val;
1770
1771 switch (op) {
1772 case BINARY_PRINT_CHAR_DATA:
1773 fprintf(output, "%c", isprint(ch) ? ch : '.');
1774 break;
1775 case BINARY_PRINT_DATA_BEGIN:
1776 case BINARY_PRINT_LINE_BEGIN:
1777 case BINARY_PRINT_ADDR:
1778 case BINARY_PRINT_NUM_DATA:
1779 case BINARY_PRINT_NUM_PAD:
1780 case BINARY_PRINT_SEP:
1781 case BINARY_PRINT_CHAR_PAD:
1782 case BINARY_PRINT_LINE_END:
1783 case BINARY_PRINT_DATA_END:
1784 default:
1785 break;
1786 }
1787 }
1788
1789 static void bpf_output__fprintf(struct trace *trace,
1790 struct perf_sample *sample)
1791 {
1792 print_binary(sample->raw_data, sample->raw_size, 8,
1793 bpf_output__printer, trace->output);
1794 }
1795
1796 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1797 union perf_event *event __maybe_unused,
1798 struct perf_sample *sample)
1799 {
1800 int callchain_ret = 0;
1801
1802 if (sample->callchain) {
1803 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1804 if (callchain_ret == 0) {
1805 if (callchain_cursor.nr < trace->min_stack)
1806 goto out;
1807 callchain_ret = 1;
1808 }
1809 }
1810
1811 trace__printf_interrupted_entry(trace, sample);
1812 trace__fprintf_tstamp(trace, sample->time, trace->output);
1813
1814 if (trace->trace_syscalls)
1815 fprintf(trace->output, "( ): ");
1816
1817 fprintf(trace->output, "%s:", evsel->name);
1818
1819 if (perf_evsel__is_bpf_output(evsel)) {
1820 bpf_output__fprintf(trace, sample);
1821 } else if (evsel->tp_format) {
1822 event_format__fprintf(evsel->tp_format, sample->cpu,
1823 sample->raw_data, sample->raw_size,
1824 trace->output);
1825 }
1826
1827 fprintf(trace->output, ")\n");
1828
1829 if (callchain_ret > 0)
1830 trace__fprintf_callchain(trace, sample);
1831 else if (callchain_ret < 0)
1832 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1833 out:
1834 return 0;
1835 }
1836
1837 static void print_location(FILE *f, struct perf_sample *sample,
1838 struct addr_location *al,
1839 bool print_dso, bool print_sym)
1840 {
1841
1842 if ((verbose || print_dso) && al->map)
1843 fprintf(f, "%s@", al->map->dso->long_name);
1844
1845 if ((verbose || print_sym) && al->sym)
1846 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
1847 al->addr - al->sym->start);
1848 else if (al->map)
1849 fprintf(f, "0x%" PRIx64, al->addr);
1850 else
1851 fprintf(f, "0x%" PRIx64, sample->addr);
1852 }
1853
1854 static int trace__pgfault(struct trace *trace,
1855 struct perf_evsel *evsel,
1856 union perf_event *event __maybe_unused,
1857 struct perf_sample *sample)
1858 {
1859 struct thread *thread;
1860 struct addr_location al;
1861 char map_type = 'd';
1862 struct thread_trace *ttrace;
1863 int err = -1;
1864 int callchain_ret = 0;
1865
1866 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1867
1868 if (sample->callchain) {
1869 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1870 if (callchain_ret == 0) {
1871 if (callchain_cursor.nr < trace->min_stack)
1872 goto out_put;
1873 callchain_ret = 1;
1874 }
1875 }
1876
1877 ttrace = thread__trace(thread, trace->output);
1878 if (ttrace == NULL)
1879 goto out_put;
1880
1881 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
1882 ttrace->pfmaj++;
1883 else
1884 ttrace->pfmin++;
1885
1886 if (trace->summary_only)
1887 goto out;
1888
1889 thread__find_addr_location(thread, sample->cpumode, MAP__FUNCTION,
1890 sample->ip, &al);
1891
1892 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1893
1894 fprintf(trace->output, "%sfault [",
1895 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1896 "maj" : "min");
1897
1898 print_location(trace->output, sample, &al, false, true);
1899
1900 fprintf(trace->output, "] => ");
1901
1902 thread__find_addr_location(thread, sample->cpumode, MAP__VARIABLE,
1903 sample->addr, &al);
1904
1905 if (!al.map) {
1906 thread__find_addr_location(thread, sample->cpumode,
1907 MAP__FUNCTION, sample->addr, &al);
1908
1909 if (al.map)
1910 map_type = 'x';
1911 else
1912 map_type = '?';
1913 }
1914
1915 print_location(trace->output, sample, &al, true, false);
1916
1917 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1918
1919 if (callchain_ret > 0)
1920 trace__fprintf_callchain(trace, sample);
1921 else if (callchain_ret < 0)
1922 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
1923 out:
1924 err = 0;
1925 out_put:
1926 thread__put(thread);
1927 return err;
1928 }
1929
1930 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1931 {
1932 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1933 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1934 return false;
1935
1936 if (trace->pid_list || trace->tid_list)
1937 return true;
1938
1939 return false;
1940 }
1941
1942 static void trace__set_base_time(struct trace *trace,
1943 struct perf_evsel *evsel,
1944 struct perf_sample *sample)
1945 {
1946 /*
1947 * BPF events were not setting PERF_SAMPLE_TIME, so be more robust
1948 * and don't use sample->time unconditionally, we may end up having
1949 * some other event in the future without PERF_SAMPLE_TIME for good
1950 * reason, i.e. we may not be interested in its timestamps, just in
1951 * it taking place, picking some piece of information when it
1952 * appears in our event stream (vfs_getname comes to mind).
1953 */
1954 if (trace->base_time == 0 && !trace->full_time &&
1955 (evsel->attr.sample_type & PERF_SAMPLE_TIME))
1956 trace->base_time = sample->time;
1957 }
1958
1959 static int trace__process_sample(struct perf_tool *tool,
1960 union perf_event *event,
1961 struct perf_sample *sample,
1962 struct perf_evsel *evsel,
1963 struct machine *machine __maybe_unused)
1964 {
1965 struct trace *trace = container_of(tool, struct trace, tool);
1966 int err = 0;
1967
1968 tracepoint_handler handler = evsel->handler;
1969
1970 if (skip_sample(trace, sample))
1971 return 0;
1972
1973 trace__set_base_time(trace, evsel, sample);
1974
1975 if (handler) {
1976 ++trace->nr_events;
1977 handler(trace, evsel, event, sample);
1978 }
1979
1980 return err;
1981 }
1982
1983 static int parse_target_str(struct trace *trace)
1984 {
1985 if (trace->opts.target.pid) {
1986 trace->pid_list = intlist__new(trace->opts.target.pid);
1987 if (trace->pid_list == NULL) {
1988 pr_err("Error parsing process id string\n");
1989 return -EINVAL;
1990 }
1991 }
1992
1993 if (trace->opts.target.tid) {
1994 trace->tid_list = intlist__new(trace->opts.target.tid);
1995 if (trace->tid_list == NULL) {
1996 pr_err("Error parsing thread id string\n");
1997 return -EINVAL;
1998 }
1999 }
2000
2001 return 0;
2002 }
2003
2004 static int trace__record(struct trace *trace, int argc, const char **argv)
2005 {
2006 unsigned int rec_argc, i, j;
2007 const char **rec_argv;
2008 const char * const record_args[] = {
2009 "record",
2010 "-R",
2011 "-m", "1024",
2012 "-c", "1",
2013 };
2014
2015 const char * const sc_args[] = { "-e", };
2016 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2017 const char * const majpf_args[] = { "-e", "major-faults" };
2018 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2019 const char * const minpf_args[] = { "-e", "minor-faults" };
2020 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2021
2022 /* +1 is for the event string below */
2023 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2024 majpf_args_nr + minpf_args_nr + argc;
2025 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2026
2027 if (rec_argv == NULL)
2028 return -ENOMEM;
2029
2030 j = 0;
2031 for (i = 0; i < ARRAY_SIZE(record_args); i++)
2032 rec_argv[j++] = record_args[i];
2033
2034 if (trace->trace_syscalls) {
2035 for (i = 0; i < sc_args_nr; i++)
2036 rec_argv[j++] = sc_args[i];
2037
2038 /* event string may be different for older kernels - e.g., RHEL6 */
2039 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2040 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2041 else if (is_valid_tracepoint("syscalls:sys_enter"))
2042 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2043 else {
2044 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2045 return -1;
2046 }
2047 }
2048
2049 if (trace->trace_pgfaults & TRACE_PFMAJ)
2050 for (i = 0; i < majpf_args_nr; i++)
2051 rec_argv[j++] = majpf_args[i];
2052
2053 if (trace->trace_pgfaults & TRACE_PFMIN)
2054 for (i = 0; i < minpf_args_nr; i++)
2055 rec_argv[j++] = minpf_args[i];
2056
2057 for (i = 0; i < (unsigned int)argc; i++)
2058 rec_argv[j++] = argv[i];
2059
2060 return cmd_record(j, rec_argv, NULL);
2061 }
2062
2063 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2064
2065 static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2066 {
2067 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2068
2069 if (IS_ERR(evsel))
2070 return false;
2071
2072 if (perf_evsel__field(evsel, "pathname") == NULL) {
2073 perf_evsel__delete(evsel);
2074 return false;
2075 }
2076
2077 evsel->handler = trace__vfs_getname;
2078 perf_evlist__add(evlist, evsel);
2079 return true;
2080 }
2081
2082 static struct perf_evsel *perf_evsel__new_pgfault(u64 config)
2083 {
2084 struct perf_evsel *evsel;
2085 struct perf_event_attr attr = {
2086 .type = PERF_TYPE_SOFTWARE,
2087 .mmap_data = 1,
2088 };
2089
2090 attr.config = config;
2091 attr.sample_period = 1;
2092
2093 event_attr_init(&attr);
2094
2095 evsel = perf_evsel__new(&attr);
2096 if (evsel)
2097 evsel->handler = trace__pgfault;
2098
2099 return evsel;
2100 }
2101
2102 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2103 {
2104 const u32 type = event->header.type;
2105 struct perf_evsel *evsel;
2106
2107 if (type != PERF_RECORD_SAMPLE) {
2108 trace__process_event(trace, trace->host, event, sample);
2109 return;
2110 }
2111
2112 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2113 if (evsel == NULL) {
2114 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2115 return;
2116 }
2117
2118 trace__set_base_time(trace, evsel, sample);
2119
2120 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2121 sample->raw_data == NULL) {
2122 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2123 perf_evsel__name(evsel), sample->tid,
2124 sample->cpu, sample->raw_size);
2125 } else {
2126 tracepoint_handler handler = evsel->handler;
2127 handler(trace, evsel, event, sample);
2128 }
2129 }
2130
2131 static int trace__add_syscall_newtp(struct trace *trace)
2132 {
2133 int ret = -1;
2134 struct perf_evlist *evlist = trace->evlist;
2135 struct perf_evsel *sys_enter, *sys_exit;
2136
2137 sys_enter = perf_evsel__syscall_newtp("sys_enter", trace__sys_enter);
2138 if (sys_enter == NULL)
2139 goto out;
2140
2141 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2142 goto out_delete_sys_enter;
2143
2144 sys_exit = perf_evsel__syscall_newtp("sys_exit", trace__sys_exit);
2145 if (sys_exit == NULL)
2146 goto out_delete_sys_enter;
2147
2148 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2149 goto out_delete_sys_exit;
2150
2151 perf_evlist__add(evlist, sys_enter);
2152 perf_evlist__add(evlist, sys_exit);
2153
2154 if (callchain_param.enabled && !trace->kernel_syscallchains) {
2155 /*
2156 * We're interested only in the user space callchain
2157 * leading to the syscall, allow overriding that for
2158 * debugging reasons using --kernel_syscall_callchains
2159 */
2160 sys_exit->attr.exclude_callchain_kernel = 1;
2161 }
2162
2163 trace->syscalls.events.sys_enter = sys_enter;
2164 trace->syscalls.events.sys_exit = sys_exit;
2165
2166 ret = 0;
2167 out:
2168 return ret;
2169
2170 out_delete_sys_exit:
2171 perf_evsel__delete_priv(sys_exit);
2172 out_delete_sys_enter:
2173 perf_evsel__delete_priv(sys_enter);
2174 goto out;
2175 }
2176
2177 static int trace__set_ev_qualifier_filter(struct trace *trace)
2178 {
2179 int err = -1;
2180 char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2181 trace->ev_qualifier_ids.nr,
2182 trace->ev_qualifier_ids.entries);
2183
2184 if (filter == NULL)
2185 goto out_enomem;
2186
2187 if (!perf_evsel__append_filter(trace->syscalls.events.sys_enter, "&&", filter))
2188 err = perf_evsel__append_filter(trace->syscalls.events.sys_exit, "&&", filter);
2189
2190 free(filter);
2191 out:
2192 return err;
2193 out_enomem:
2194 errno = ENOMEM;
2195 goto out;
2196 }
2197
2198 static int trace__run(struct trace *trace, int argc, const char **argv)
2199 {
2200 struct perf_evlist *evlist = trace->evlist;
2201 struct perf_evsel *evsel, *pgfault_maj = NULL, *pgfault_min = NULL;
2202 int err = -1, i;
2203 unsigned long before;
2204 const bool forks = argc > 0;
2205 bool draining = false;
2206
2207 trace->live = true;
2208
2209 if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
2210 goto out_error_raw_syscalls;
2211
2212 if (trace->trace_syscalls)
2213 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
2214
2215 if ((trace->trace_pgfaults & TRACE_PFMAJ)) {
2216 pgfault_maj = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MAJ);
2217 if (pgfault_maj == NULL)
2218 goto out_error_mem;
2219 perf_evlist__add(evlist, pgfault_maj);
2220 }
2221
2222 if ((trace->trace_pgfaults & TRACE_PFMIN)) {
2223 pgfault_min = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MIN);
2224 if (pgfault_min == NULL)
2225 goto out_error_mem;
2226 perf_evlist__add(evlist, pgfault_min);
2227 }
2228
2229 if (trace->sched &&
2230 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2231 trace__sched_stat_runtime))
2232 goto out_error_sched_stat_runtime;
2233
2234 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2235 if (err < 0) {
2236 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2237 goto out_delete_evlist;
2238 }
2239
2240 err = trace__symbols_init(trace, evlist);
2241 if (err < 0) {
2242 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2243 goto out_delete_evlist;
2244 }
2245
2246 perf_evlist__config(evlist, &trace->opts, NULL);
2247
2248 if (callchain_param.enabled) {
2249 bool use_identifier = false;
2250
2251 if (trace->syscalls.events.sys_exit) {
2252 perf_evsel__config_callchain(trace->syscalls.events.sys_exit,
2253 &trace->opts, &callchain_param);
2254 use_identifier = true;
2255 }
2256
2257 if (pgfault_maj) {
2258 perf_evsel__config_callchain(pgfault_maj, &trace->opts, &callchain_param);
2259 use_identifier = true;
2260 }
2261
2262 if (pgfault_min) {
2263 perf_evsel__config_callchain(pgfault_min, &trace->opts, &callchain_param);
2264 use_identifier = true;
2265 }
2266
2267 if (use_identifier) {
2268 /*
2269 * Now we have evsels with different sample_ids, use
2270 * PERF_SAMPLE_IDENTIFIER to map from sample to evsel
2271 * from a fixed position in each ring buffer record.
2272 *
2273 * As of this the changeset introducing this comment, this
2274 * isn't strictly needed, as the fields that can come before
2275 * PERF_SAMPLE_ID are all used, but we'll probably disable
2276 * some of those for things like copying the payload of
2277 * pointer syscall arguments, and for vfs_getname we don't
2278 * need PERF_SAMPLE_ADDR and PERF_SAMPLE_IP, so do this
2279 * here as a warning we need to use PERF_SAMPLE_IDENTIFIER.
2280 */
2281 perf_evlist__set_sample_bit(evlist, IDENTIFIER);
2282 perf_evlist__reset_sample_bit(evlist, ID);
2283 }
2284 }
2285
2286 signal(SIGCHLD, sig_handler);
2287 signal(SIGINT, sig_handler);
2288
2289 if (forks) {
2290 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2291 argv, false, NULL);
2292 if (err < 0) {
2293 fprintf(trace->output, "Couldn't run the workload!\n");
2294 goto out_delete_evlist;
2295 }
2296 }
2297
2298 err = perf_evlist__open(evlist);
2299 if (err < 0)
2300 goto out_error_open;
2301
2302 err = bpf__apply_obj_config();
2303 if (err) {
2304 char errbuf[BUFSIZ];
2305
2306 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
2307 pr_err("ERROR: Apply config to BPF failed: %s\n",
2308 errbuf);
2309 goto out_error_open;
2310 }
2311
2312 /*
2313 * Better not use !target__has_task() here because we need to cover the
2314 * case where no threads were specified in the command line, but a
2315 * workload was, and in that case we will fill in the thread_map when
2316 * we fork the workload in perf_evlist__prepare_workload.
2317 */
2318 if (trace->filter_pids.nr > 0)
2319 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2320 else if (thread_map__pid(evlist->threads, 0) == -1)
2321 err = perf_evlist__set_filter_pid(evlist, getpid());
2322
2323 if (err < 0)
2324 goto out_error_mem;
2325
2326 if (trace->ev_qualifier_ids.nr > 0) {
2327 err = trace__set_ev_qualifier_filter(trace);
2328 if (err < 0)
2329 goto out_errno;
2330
2331 pr_debug("event qualifier tracepoint filter: %s\n",
2332 trace->syscalls.events.sys_exit->filter);
2333 }
2334
2335 err = perf_evlist__apply_filters(evlist, &evsel);
2336 if (err < 0)
2337 goto out_error_apply_filters;
2338
2339 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2340 if (err < 0)
2341 goto out_error_mmap;
2342
2343 if (!target__none(&trace->opts.target))
2344 perf_evlist__enable(evlist);
2345
2346 if (forks)
2347 perf_evlist__start_workload(evlist);
2348
2349 trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
2350 evlist->threads->nr > 1 ||
2351 perf_evlist__first(evlist)->attr.inherit;
2352 again:
2353 before = trace->nr_events;
2354
2355 for (i = 0; i < evlist->nr_mmaps; i++) {
2356 union perf_event *event;
2357
2358 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2359 struct perf_sample sample;
2360
2361 ++trace->nr_events;
2362
2363 err = perf_evlist__parse_sample(evlist, event, &sample);
2364 if (err) {
2365 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2366 goto next_event;
2367 }
2368
2369 trace__handle_event(trace, event, &sample);
2370 next_event:
2371 perf_evlist__mmap_consume(evlist, i);
2372
2373 if (interrupted)
2374 goto out_disable;
2375
2376 if (done && !draining) {
2377 perf_evlist__disable(evlist);
2378 draining = true;
2379 }
2380 }
2381 }
2382
2383 if (trace->nr_events == before) {
2384 int timeout = done ? 100 : -1;
2385
2386 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2387 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2388 draining = true;
2389
2390 goto again;
2391 }
2392 } else {
2393 goto again;
2394 }
2395
2396 out_disable:
2397 thread__zput(trace->current);
2398
2399 perf_evlist__disable(evlist);
2400
2401 if (!err) {
2402 if (trace->summary)
2403 trace__fprintf_thread_summary(trace, trace->output);
2404
2405 if (trace->show_tool_stats) {
2406 fprintf(trace->output, "Stats:\n "
2407 " vfs_getname : %" PRIu64 "\n"
2408 " proc_getname: %" PRIu64 "\n",
2409 trace->stats.vfs_getname,
2410 trace->stats.proc_getname);
2411 }
2412 }
2413
2414 out_delete_evlist:
2415 perf_evlist__delete(evlist);
2416 trace->evlist = NULL;
2417 trace->live = false;
2418 return err;
2419 {
2420 char errbuf[BUFSIZ];
2421
2422 out_error_sched_stat_runtime:
2423 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2424 goto out_error;
2425
2426 out_error_raw_syscalls:
2427 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2428 goto out_error;
2429
2430 out_error_mmap:
2431 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2432 goto out_error;
2433
2434 out_error_open:
2435 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2436
2437 out_error:
2438 fprintf(trace->output, "%s\n", errbuf);
2439 goto out_delete_evlist;
2440
2441 out_error_apply_filters:
2442 fprintf(trace->output,
2443 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2444 evsel->filter, perf_evsel__name(evsel), errno,
2445 strerror_r(errno, errbuf, sizeof(errbuf)));
2446 goto out_delete_evlist;
2447 }
2448 out_error_mem:
2449 fprintf(trace->output, "Not enough memory to run!\n");
2450 goto out_delete_evlist;
2451
2452 out_errno:
2453 fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2454 goto out_delete_evlist;
2455 }
2456
2457 static int trace__replay(struct trace *trace)
2458 {
2459 const struct perf_evsel_str_handler handlers[] = {
2460 { "probe:vfs_getname", trace__vfs_getname, },
2461 };
2462 struct perf_data_file file = {
2463 .path = input_name,
2464 .mode = PERF_DATA_MODE_READ,
2465 .force = trace->force,
2466 };
2467 struct perf_session *session;
2468 struct perf_evsel *evsel;
2469 int err = -1;
2470
2471 trace->tool.sample = trace__process_sample;
2472 trace->tool.mmap = perf_event__process_mmap;
2473 trace->tool.mmap2 = perf_event__process_mmap2;
2474 trace->tool.comm = perf_event__process_comm;
2475 trace->tool.exit = perf_event__process_exit;
2476 trace->tool.fork = perf_event__process_fork;
2477 trace->tool.attr = perf_event__process_attr;
2478 trace->tool.tracing_data = perf_event__process_tracing_data;
2479 trace->tool.build_id = perf_event__process_build_id;
2480
2481 trace->tool.ordered_events = true;
2482 trace->tool.ordering_requires_timestamps = true;
2483
2484 /* add tid to output */
2485 trace->multiple_threads = true;
2486
2487 session = perf_session__new(&file, false, &trace->tool);
2488 if (session == NULL)
2489 return -1;
2490
2491 if (symbol__init(&session->header.env) < 0)
2492 goto out;
2493
2494 trace->host = &session->machines.host;
2495
2496 err = perf_session__set_tracepoints_handlers(session, handlers);
2497 if (err)
2498 goto out;
2499
2500 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2501 "raw_syscalls:sys_enter");
2502 /* older kernels have syscalls tp versus raw_syscalls */
2503 if (evsel == NULL)
2504 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2505 "syscalls:sys_enter");
2506
2507 if (evsel &&
2508 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2509 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2510 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2511 goto out;
2512 }
2513
2514 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2515 "raw_syscalls:sys_exit");
2516 if (evsel == NULL)
2517 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2518 "syscalls:sys_exit");
2519 if (evsel &&
2520 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2521 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2522 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2523 goto out;
2524 }
2525
2526 evlist__for_each(session->evlist, evsel) {
2527 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2528 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2529 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2530 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2531 evsel->handler = trace__pgfault;
2532 }
2533
2534 err = parse_target_str(trace);
2535 if (err != 0)
2536 goto out;
2537
2538 setup_pager();
2539
2540 err = perf_session__process_events(session);
2541 if (err)
2542 pr_err("Failed to process events, error %d", err);
2543
2544 else if (trace->summary)
2545 trace__fprintf_thread_summary(trace, trace->output);
2546
2547 out:
2548 perf_session__delete(session);
2549
2550 return err;
2551 }
2552
2553 static size_t trace__fprintf_threads_header(FILE *fp)
2554 {
2555 size_t printed;
2556
2557 printed = fprintf(fp, "\n Summary of events:\n\n");
2558
2559 return printed;
2560 }
2561
2562 DEFINE_RESORT_RB(syscall_stats, a->msecs > b->msecs,
2563 struct stats *stats;
2564 double msecs;
2565 int syscall;
2566 )
2567 {
2568 struct int_node *source = rb_entry(nd, struct int_node, rb_node);
2569 struct stats *stats = source->priv;
2570
2571 entry->syscall = source->i;
2572 entry->stats = stats;
2573 entry->msecs = stats ? (u64)stats->n * (avg_stats(stats) / NSEC_PER_MSEC) : 0;
2574 }
2575
2576 static size_t thread__dump_stats(struct thread_trace *ttrace,
2577 struct trace *trace, FILE *fp)
2578 {
2579 size_t printed = 0;
2580 struct syscall *sc;
2581 struct rb_node *nd;
2582 DECLARE_RESORT_RB_INTLIST(syscall_stats, ttrace->syscall_stats);
2583
2584 if (syscall_stats == NULL)
2585 return 0;
2586
2587 printed += fprintf(fp, "\n");
2588
2589 printed += fprintf(fp, " syscall calls total min avg max stddev\n");
2590 printed += fprintf(fp, " (msec) (msec) (msec) (msec) (%%)\n");
2591 printed += fprintf(fp, " --------------- -------- --------- --------- --------- --------- ------\n");
2592
2593 resort_rb__for_each(nd, syscall_stats) {
2594 struct stats *stats = syscall_stats_entry->stats;
2595 if (stats) {
2596 double min = (double)(stats->min) / NSEC_PER_MSEC;
2597 double max = (double)(stats->max) / NSEC_PER_MSEC;
2598 double avg = avg_stats(stats);
2599 double pct;
2600 u64 n = (u64) stats->n;
2601
2602 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2603 avg /= NSEC_PER_MSEC;
2604
2605 sc = &trace->syscalls.table[syscall_stats_entry->syscall];
2606 printed += fprintf(fp, " %-15s", sc->name);
2607 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
2608 n, syscall_stats_entry->msecs, min, avg);
2609 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2610 }
2611 }
2612
2613 resort_rb__delete(syscall_stats);
2614 printed += fprintf(fp, "\n\n");
2615
2616 return printed;
2617 }
2618
2619 static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
2620 {
2621 size_t printed = 0;
2622 struct thread_trace *ttrace = thread__priv(thread);
2623 double ratio;
2624
2625 if (ttrace == NULL)
2626 return 0;
2627
2628 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2629
2630 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2631 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2632 printed += fprintf(fp, "%.1f%%", ratio);
2633 if (ttrace->pfmaj)
2634 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2635 if (ttrace->pfmin)
2636 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2637 if (trace->sched)
2638 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2639 else if (fputc('\n', fp) != EOF)
2640 ++printed;
2641
2642 printed += thread__dump_stats(ttrace, trace, fp);
2643
2644 return printed;
2645 }
2646
2647 static unsigned long thread__nr_events(struct thread_trace *ttrace)
2648 {
2649 return ttrace ? ttrace->nr_events : 0;
2650 }
2651
2652 DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)),
2653 struct thread *thread;
2654 )
2655 {
2656 entry->thread = rb_entry(nd, struct thread, rb_node);
2657 }
2658
2659 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2660 {
2661 DECLARE_RESORT_RB_MACHINE_THREADS(threads, trace->host);
2662 size_t printed = trace__fprintf_threads_header(fp);
2663 struct rb_node *nd;
2664
2665 if (threads == NULL) {
2666 fprintf(fp, "%s", "Error sorting output by nr_events!\n");
2667 return 0;
2668 }
2669
2670 resort_rb__for_each(nd, threads)
2671 printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
2672
2673 resort_rb__delete(threads);
2674
2675 return printed;
2676 }
2677
2678 static int trace__set_duration(const struct option *opt, const char *str,
2679 int unset __maybe_unused)
2680 {
2681 struct trace *trace = opt->value;
2682
2683 trace->duration_filter = atof(str);
2684 return 0;
2685 }
2686
2687 static int trace__set_filter_pids(const struct option *opt, const char *str,
2688 int unset __maybe_unused)
2689 {
2690 int ret = -1;
2691 size_t i;
2692 struct trace *trace = opt->value;
2693 /*
2694 * FIXME: introduce a intarray class, plain parse csv and create a
2695 * { int nr, int entries[] } struct...
2696 */
2697 struct intlist *list = intlist__new(str);
2698
2699 if (list == NULL)
2700 return -1;
2701
2702 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2703 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2704
2705 if (trace->filter_pids.entries == NULL)
2706 goto out;
2707
2708 trace->filter_pids.entries[0] = getpid();
2709
2710 for (i = 1; i < trace->filter_pids.nr; ++i)
2711 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2712
2713 intlist__delete(list);
2714 ret = 0;
2715 out:
2716 return ret;
2717 }
2718
2719 static int trace__open_output(struct trace *trace, const char *filename)
2720 {
2721 struct stat st;
2722
2723 if (!stat(filename, &st) && st.st_size) {
2724 char oldname[PATH_MAX];
2725
2726 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2727 unlink(oldname);
2728 rename(filename, oldname);
2729 }
2730
2731 trace->output = fopen(filename, "w");
2732
2733 return trace->output == NULL ? -errno : 0;
2734 }
2735
2736 static int parse_pagefaults(const struct option *opt, const char *str,
2737 int unset __maybe_unused)
2738 {
2739 int *trace_pgfaults = opt->value;
2740
2741 if (strcmp(str, "all") == 0)
2742 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2743 else if (strcmp(str, "maj") == 0)
2744 *trace_pgfaults |= TRACE_PFMAJ;
2745 else if (strcmp(str, "min") == 0)
2746 *trace_pgfaults |= TRACE_PFMIN;
2747 else
2748 return -1;
2749
2750 return 0;
2751 }
2752
2753 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2754 {
2755 struct perf_evsel *evsel;
2756
2757 evlist__for_each(evlist, evsel)
2758 evsel->handler = handler;
2759 }
2760
2761 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2762 {
2763 const char *trace_usage[] = {
2764 "perf trace [<options>] [<command>]",
2765 "perf trace [<options>] -- <command> [<options>]",
2766 "perf trace record [<options>] [<command>]",
2767 "perf trace record [<options>] -- <command> [<options>]",
2768 NULL
2769 };
2770 struct trace trace = {
2771 .syscalls = {
2772 . max = -1,
2773 },
2774 .opts = {
2775 .target = {
2776 .uid = UINT_MAX,
2777 .uses_mmap = true,
2778 },
2779 .user_freq = UINT_MAX,
2780 .user_interval = ULLONG_MAX,
2781 .no_buffering = true,
2782 .mmap_pages = UINT_MAX,
2783 .proc_map_timeout = 500,
2784 },
2785 .output = stderr,
2786 .show_comm = true,
2787 .trace_syscalls = true,
2788 .kernel_syscallchains = false,
2789 .max_stack = UINT_MAX,
2790 };
2791 const char *output_name = NULL;
2792 const char *ev_qualifier_str = NULL;
2793 const struct option trace_options[] = {
2794 OPT_CALLBACK(0, "event", &trace.evlist, "event",
2795 "event selector. use 'perf list' to list available events",
2796 parse_events_option),
2797 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2798 "show the thread COMM next to its id"),
2799 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2800 OPT_STRING('e', "expr", &ev_qualifier_str, "expr", "list of syscalls to trace"),
2801 OPT_STRING('o', "output", &output_name, "file", "output file name"),
2802 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
2803 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2804 "trace events on existing process id"),
2805 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
2806 "trace events on existing thread id"),
2807 OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
2808 "pids to filter (by the kernel)", trace__set_filter_pids),
2809 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
2810 "system-wide collection from all CPUs"),
2811 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
2812 "list of cpus to monitor"),
2813 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
2814 "child tasks do not inherit counters"),
2815 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2816 "number of mmap data pages",
2817 perf_evlist__parse_mmap_pages),
2818 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
2819 "user to profile"),
2820 OPT_CALLBACK(0, "duration", &trace, "float",
2821 "show only events with duration > N.M ms",
2822 trace__set_duration),
2823 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
2824 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
2825 OPT_BOOLEAN('T', "time", &trace.full_time,
2826 "Show full timestamp, not time relative to first start"),
2827 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2828 "Show only syscall summary with statistics"),
2829 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2830 "Show all syscalls and summary with statistics"),
2831 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2832 "Trace pagefaults", parse_pagefaults, "maj"),
2833 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
2834 OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
2835 OPT_CALLBACK(0, "call-graph", &trace.opts,
2836 "record_mode[,record_size]", record_callchain_help,
2837 &record_parse_callchain_opt),
2838 OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
2839 "Show the kernel callchains on the syscall exit path"),
2840 OPT_UINTEGER(0, "min-stack", &trace.min_stack,
2841 "Set the minimum stack depth when parsing the callchain, "
2842 "anything below the specified depth will be ignored."),
2843 OPT_UINTEGER(0, "max-stack", &trace.max_stack,
2844 "Set the maximum stack depth when parsing the callchain, "
2845 "anything beyond the specified depth will be ignored. "
2846 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
2847 OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
2848 "per thread proc mmap processing timeout in ms"),
2849 OPT_END()
2850 };
2851 bool __maybe_unused max_stack_user_set = true;
2852 bool mmap_pages_user_set = true;
2853 const char * const trace_subcommands[] = { "record", NULL };
2854 int err;
2855 char bf[BUFSIZ];
2856
2857 signal(SIGSEGV, sighandler_dump_stack);
2858 signal(SIGFPE, sighandler_dump_stack);
2859
2860 trace.evlist = perf_evlist__new();
2861 trace.sctbl = syscalltbl__new();
2862
2863 if (trace.evlist == NULL || trace.sctbl == NULL) {
2864 pr_err("Not enough memory to run!\n");
2865 err = -ENOMEM;
2866 goto out;
2867 }
2868
2869 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
2870 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
2871
2872 err = bpf__setup_stdout(trace.evlist);
2873 if (err) {
2874 bpf__strerror_setup_stdout(trace.evlist, err, bf, sizeof(bf));
2875 pr_err("ERROR: Setup BPF stdout failed: %s\n", bf);
2876 goto out;
2877 }
2878
2879 err = -1;
2880
2881 if (trace.trace_pgfaults) {
2882 trace.opts.sample_address = true;
2883 trace.opts.sample_time = true;
2884 }
2885
2886 if (trace.opts.mmap_pages == UINT_MAX)
2887 mmap_pages_user_set = false;
2888
2889 if (trace.max_stack == UINT_MAX) {
2890 trace.max_stack = sysctl_perf_event_max_stack;
2891 max_stack_user_set = false;
2892 }
2893
2894 #ifdef HAVE_DWARF_UNWIND_SUPPORT
2895 if ((trace.min_stack || max_stack_user_set) && !callchain_param.enabled)
2896 record_opts__parse_callchain(&trace.opts, &callchain_param, "dwarf", false);
2897 #endif
2898
2899 if (callchain_param.enabled) {
2900 if (!mmap_pages_user_set && geteuid() == 0)
2901 trace.opts.mmap_pages = perf_event_mlock_kb_in_pages() * 4;
2902
2903 symbol_conf.use_callchain = true;
2904 }
2905
2906 if (trace.evlist->nr_entries > 0)
2907 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
2908
2909 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2910 return trace__record(&trace, argc-1, &argv[1]);
2911
2912 /* summary_only implies summary option, but don't overwrite summary if set */
2913 if (trace.summary_only)
2914 trace.summary = trace.summary_only;
2915
2916 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
2917 trace.evlist->nr_entries == 0 /* Was --events used? */) {
2918 pr_err("Please specify something to trace.\n");
2919 return -1;
2920 }
2921
2922 if (!trace.trace_syscalls && ev_qualifier_str) {
2923 pr_err("The -e option can't be used with --no-syscalls.\n");
2924 goto out;
2925 }
2926
2927 if (output_name != NULL) {
2928 err = trace__open_output(&trace, output_name);
2929 if (err < 0) {
2930 perror("failed to create output file");
2931 goto out;
2932 }
2933 }
2934
2935 trace.open_id = syscalltbl__id(trace.sctbl, "open");
2936
2937 if (ev_qualifier_str != NULL) {
2938 const char *s = ev_qualifier_str;
2939 struct strlist_config slist_config = {
2940 .dirname = system_path(STRACE_GROUPS_DIR),
2941 };
2942
2943 trace.not_ev_qualifier = *s == '!';
2944 if (trace.not_ev_qualifier)
2945 ++s;
2946 trace.ev_qualifier = strlist__new(s, &slist_config);
2947 if (trace.ev_qualifier == NULL) {
2948 fputs("Not enough memory to parse event qualifier",
2949 trace.output);
2950 err = -ENOMEM;
2951 goto out_close;
2952 }
2953
2954 err = trace__validate_ev_qualifier(&trace);
2955 if (err)
2956 goto out_close;
2957 }
2958
2959 err = target__validate(&trace.opts.target);
2960 if (err) {
2961 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2962 fprintf(trace.output, "%s", bf);
2963 goto out_close;
2964 }
2965
2966 err = target__parse_uid(&trace.opts.target);
2967 if (err) {
2968 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2969 fprintf(trace.output, "%s", bf);
2970 goto out_close;
2971 }
2972
2973 if (!argc && target__none(&trace.opts.target))
2974 trace.opts.target.system_wide = true;
2975
2976 if (input_name)
2977 err = trace__replay(&trace);
2978 else
2979 err = trace__run(&trace, argc, argv);
2980
2981 out_close:
2982 if (output_name != NULL)
2983 fclose(trace.output);
2984 out:
2985 return err;
2986 }
Linux kernel - Deliverables
This page took 0.448994 seconds and 6 git commands to generate.