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