projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf trace: Beautify mount's first pathname arg
[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"
9ea42ba4 22#include "util/cgroup.h"
752fde44 23#include "util/color.h"
7c304ee0 24#include "util/debug.h"
092bd3cd 25#include "util/env.h"
5ab8c689 26#include "util/event.h"
514f1c67 27#include "util/evlist.h"
4b6ab94e 28#include <subcmd/exec-cmd.h>
752fde44 29#include "util/machine.h"
9a3993d4 30#include "util/path.h"
6810fc91 31#include "util/session.h"
752fde44 32#include "util/thread.h"
4b6ab94e 33#include <subcmd/parse-options.h>
2ae3a312 34#include "util/strlist.h"
bdc89661 35#include "util/intlist.h"
514f1c67 36#include "util/thread_map.h"
bf2575c1 37#include "util/stat.h"
fd5cead2 38#include "trace/beauty/beauty.h"
97978b3e 39#include "trace-event.h"
9aca7f17 40#include "util/parse-events.h"
ba504235 41#include "util/bpf-loader.h"
566a0885 42#include "callchain.h"
fea01392 43#include "print_binary.h"
a067558e 44#include "string2.h"
fd0db102 45#include "syscalltbl.h"
96c14451 46#include "rb_resort.h"
514f1c67 47
a43783ae 48#include <errno.h>
fd20e811 49#include <inttypes.h>
4208735d 50#include <poll.h>
9607ad3a 51#include <signal.h>
514f1c67 52#include <stdlib.h>
017037ff 53#include <string.h>
8dd2a131 54#include <linux/err.h>
997bba8c 55#include <linux/filter.h>
877a7a11 56#include <linux/kernel.h>
39878d49 57#include <linux/random.h>
c6d4a494 58#include <linux/stringify.h>
bd48c63e 59#include <linux/time64.h>
bafae98e 60#include <fcntl.h>
514f1c67 61
3d689ed6
ACM		 62#include "sane_ctype.h"
63
c188e7ac
ACM		 64#ifndef O_CLOEXEC
65# define O_CLOEXEC 02000000
66#endif
67
83a51694
ACM		 68#ifndef F_LINUX_SPECIFIC_BASE
69# define F_LINUX_SPECIFIC_BASE 1024
70#endif
71
d1d438a3
ACM		 72struct trace {
73 struct perf_tool tool;
fd0db102 74 struct syscalltbl *sctbl;
d1d438a3
ACM		 75 struct {
76 int max;
77 struct syscall *table;
78 struct {
79 struct perf_evsel *sys_enter,
d3d1c4bd
ACM		 80 *sys_exit,
81 *augmented;
d1d438a3
ACM		 82 } events;
83 } syscalls;
84 struct record_opts opts;
85 struct perf_evlist *evlist;
86 struct machine *host;
87 struct thread *current;
9ea42ba4 88 struct cgroup *cgroup;
d1d438a3
ACM		 89 u64 base_time;
90 FILE *output;
91 unsigned long nr_events;
5067a8cd
ACM		 92 unsigned long nr_events_printed;
93 unsigned long max_events;
d1d438a3
ACM		 94 struct strlist *ev_qualifier;
95 struct {
96 size_t nr;
97 int *entries;
98 } ev_qualifier_ids;
d1d438a3
ACM		 99 struct {
100 size_t nr;
101 pid_t *entries;
102 } filter_pids;
103 double duration_filter;
104 double runtime_ms;
105 struct {
106 u64 vfs_getname,
107 proc_getname;
108 } stats;
c6d4a494 109 unsigned int max_stack;
5cf9c84e 110 unsigned int min_stack;
d1d438a3
ACM		 111 bool not_ev_qualifier;
112 bool live;
113 bool full_time;
114 bool sched;
115 bool multiple_threads;
116 bool summary;
117 bool summary_only;
0a6545bd 118 bool failure_only;
d1d438a3 119 bool show_comm;
591421e1 120 bool print_sample;
d1d438a3
ACM		 121 bool show_tool_stats;
122 bool trace_syscalls;
44621819 123 bool kernel_syscallchains;
d1d438a3
ACM		 124 bool force;
125 bool vfs_getname;
126 int trace_pgfaults;
127};
a1c2552d 128
77170988
ACM		 129struct tp_field {
130 int offset;
131 union {
132 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
133 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
134 };
135};
136
137#define TP_UINT_FIELD(bits) \
138static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
139{ \
55d43bca
DA		 140 u##bits value; \
141 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
142 return value; \
77170988
ACM		 143}
144
145TP_UINT_FIELD(8);
146TP_UINT_FIELD(16);
147TP_UINT_FIELD(32);
148TP_UINT_FIELD(64);
149
150#define TP_UINT_FIELD__SWAPPED(bits) \
151static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
152{ \
55d43bca
DA		 153 u##bits value; \
154 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
77170988
ACM		 155 return bswap_##bits(value);\
156}
157
158TP_UINT_FIELD__SWAPPED(16);
159TP_UINT_FIELD__SWAPPED(32);
160TP_UINT_FIELD__SWAPPED(64);
161
aa823f58 162static int __tp_field__init_uint(struct tp_field *field, int size, int offset, bool needs_swap)
77170988 163{
aa823f58 164 field->offset = offset;
77170988 165
aa823f58 166 switch (size) {
77170988
ACM		 167 case 1:
168 field->integer = tp_field__u8;
169 break;
170 case 2:
171 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
172 break;
173 case 4:
174 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
175 break;
176 case 8:
177 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
178 break;
179 default:
180 return -1;
181 }
182
183 return 0;
184}
185
2c92f982 186static int tp_field__init_uint(struct tp_field *field, struct tep_format_field *format_field, bool needs_swap)
aa823f58
ACM		 187{
188 return __tp_field__init_uint(field, format_field->size, format_field->offset, needs_swap);
189}
190
77170988
ACM		 191static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
192{
193 return sample->raw_data + field->offset;
194}
195
aa823f58 196static int __tp_field__init_ptr(struct tp_field *field, int offset)
77170988 197{
aa823f58 198 field->offset = offset;
77170988
ACM		 199 field->pointer = tp_field__ptr;
200 return 0;
201}
202
2c92f982 203static int tp_field__init_ptr(struct tp_field *field, struct tep_format_field *format_field)
aa823f58
ACM		 204{
205 return __tp_field__init_ptr(field, format_field->offset);
206}
207
77170988
ACM		 208struct syscall_tp {
209 struct tp_field id;
210 union {
211 struct tp_field args, ret;
212 };
213};
214
215static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
216 struct tp_field *field,
217 const char *name)
218{
2c92f982 219 struct tep_format_field *format_field = perf_evsel__field(evsel, name);
77170988
ACM		 220
221 if (format_field == NULL)
222 return -1;
223
224 return tp_field__init_uint(field, format_field, evsel->needs_swap);
225}
226
227#define perf_evsel__init_sc_tp_uint_field(evsel, name) \
228 ({ struct syscall_tp *sc = evsel->priv;\
229 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
230
231static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
232 struct tp_field *field,
233 const char *name)
234{
2c92f982 235 struct tep_format_field *format_field = perf_evsel__field(evsel, name);
77170988
ACM		 236
237 if (format_field == NULL)
238 return -1;
239
240 return tp_field__init_ptr(field, format_field);
241}
242
243#define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
244 ({ struct syscall_tp *sc = evsel->priv;\
245 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
246
247static void perf_evsel__delete_priv(struct perf_evsel *evsel)
248{
04662523 249 zfree(&evsel->priv);
77170988
ACM		 250 perf_evsel__delete(evsel);
251}
252
d32855fa
ACM		 253static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel)
254{
255 struct syscall_tp *sc = evsel->priv = malloc(sizeof(struct syscall_tp));
256
257 if (evsel->priv != NULL) {
258 if (perf_evsel__init_tp_uint_field(evsel, &sc->id, "__syscall_nr"))
259 goto out_delete;
260 return 0;
261 }
262
263 return -ENOMEM;
264out_delete:
265 zfree(&evsel->priv);
266 return -ENOENT;
267}
268
d3d1c4bd
ACM		 269static int perf_evsel__init_augmented_syscall_tp(struct perf_evsel *evsel)
270{
271 struct syscall_tp *sc = evsel->priv = malloc(sizeof(struct syscall_tp));
272
273 if (evsel->priv != NULL) { /* field, sizeof_field, offsetof_field */
274 if (__tp_field__init_uint(&sc->id, sizeof(long), sizeof(long long), evsel->needs_swap))
275 goto out_delete;
276
277 return 0;
278 }
279
280 return -ENOMEM;
281out_delete:
282 zfree(&evsel->priv);
283 return -EINVAL;
284}
285
286static int perf_evsel__init_augmented_syscall_tp_args(struct perf_evsel *evsel)
287{
288 struct syscall_tp *sc = evsel->priv;
289
290 return __tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64));
291}
292
b1a9e253
ACM		 293static int perf_evsel__init_augmented_syscall_tp_ret(struct perf_evsel *evsel)
294{
295 struct syscall_tp *sc = evsel->priv;
296
297 return __tp_field__init_uint(&sc->ret, sizeof(u64), sc->id.offset + sizeof(u64), evsel->needs_swap);
298}
299
63f11c80 300static int perf_evsel__init_raw_syscall_tp(struct perf_evsel *evsel, void *handler)
96695d44
NK		 301{
302 evsel->priv = malloc(sizeof(struct syscall_tp));
303 if (evsel->priv != NULL) {
304 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
305 goto out_delete;
306
307 evsel->handler = handler;
308 return 0;
309 }
310
311 return -ENOMEM;
312
313out_delete:
04662523 314 zfree(&evsel->priv);
96695d44
NK		 315 return -ENOENT;
316}
317
63f11c80 318static struct perf_evsel *perf_evsel__raw_syscall_newtp(const char *direction, void *handler)
77170988 319{
ef503831 320 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
77170988 321
9aca7f17 322 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
8dd2a131 323 if (IS_ERR(evsel))
9aca7f17
DA		 324 evsel = perf_evsel__newtp("syscalls", direction);
325
8dd2a131
JO		 326 if (IS_ERR(evsel))
327 return NULL;
328
63f11c80 329 if (perf_evsel__init_raw_syscall_tp(evsel, handler))
8dd2a131 330 goto out_delete;
77170988
ACM		 331
332 return evsel;
333
334out_delete:
335 perf_evsel__delete_priv(evsel);
336 return NULL;
337}
338
339#define perf_evsel__sc_tp_uint(evsel, name, sample) \
340 ({ struct syscall_tp *fields = evsel->priv; \
341 fields->name.integer(&fields->name, sample); })
342
343#define perf_evsel__sc_tp_ptr(evsel, name, sample) \
344 ({ struct syscall_tp *fields = evsel->priv; \
345 fields->name.pointer(&fields->name, sample); })
346
0ae79636
ACM		 347size_t strarray__scnprintf(struct strarray *sa, char *bf, size_t size, const char *intfmt, int val)
348{
349 int idx = val - sa->offset;
1f115cb7 350
bc972ada 351 if (idx < 0 || idx >= sa->nr_entries || sa->entries[idx] == NULL)
0ae79636 352 return scnprintf(bf, size, intfmt, val);
1f115cb7 353
0ae79636 354 return scnprintf(bf, size, "%s", sa->entries[idx]);
03e3adc9
ACM		 355}
356
975b7c2f
ACM		 357static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
358 const char *intfmt,
359 struct syscall_arg *arg)
1f115cb7 360{
0ae79636 361 return strarray__scnprintf(arg->parm, bf, size, intfmt, arg->val);
1f115cb7
ACM		 362}
363
975b7c2f
ACM		 364static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
365 struct syscall_arg *arg)
366{
367 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
368}
369
1f115cb7
ACM		 370#define SCA_STRARRAY syscall_arg__scnprintf_strarray
371
83a51694
ACM		 372struct strarrays {
373 int nr_entries;
374 struct strarray **entries;
375};
376
377#define DEFINE_STRARRAYS(array) struct strarrays strarrays__##array = { \
378 .nr_entries = ARRAY_SIZE(array), \
379 .entries = array, \
380}
381
274e86fd
ACM		 382size_t syscall_arg__scnprintf_strarrays(char *bf, size_t size,
383 struct syscall_arg *arg)
83a51694
ACM		 384{
385 struct strarrays *sas = arg->parm;
386 int i;
387
388 for (i = 0; i < sas->nr_entries; ++i) {
389 struct strarray *sa = sas->entries[i];
390 int idx = arg->val - sa->offset;
391
392 if (idx >= 0 && idx < sa->nr_entries) {
393 if (sa->entries[idx] == NULL)
394 break;
395 return scnprintf(bf, size, "%s", sa->entries[idx]);
396 }
397 }
398
399 return scnprintf(bf, size, "%d", arg->val);
400}
401
48e1f91a
ACM		 402#ifndef AT_FDCWD
403#define AT_FDCWD -100
404#endif
405
75b757ca
ACM		 406static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
407 struct syscall_arg *arg)
408{
409 int fd = arg->val;
410
411 if (fd == AT_FDCWD)
412 return scnprintf(bf, size, "CWD");
413
414 return syscall_arg__scnprintf_fd(bf, size, arg);
415}
416
417#define SCA_FDAT syscall_arg__scnprintf_fd_at
418
419static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
420 struct syscall_arg *arg);
421
422#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
423
2c2b1623 424size_t syscall_arg__scnprintf_hex(char *bf, size_t size, struct syscall_arg *arg)
13d4ff3e 425{
01533e97 426 return scnprintf(bf, size, "%#lx", arg->val);
13d4ff3e
ACM		 427}
428
2c2b1623 429size_t syscall_arg__scnprintf_int(char *bf, size_t size, struct syscall_arg *arg)
a1c2552d
ACM		 430{
431 return scnprintf(bf, size, "%d", arg->val);
432}
433
5dde91ed
ACM		 434size_t syscall_arg__scnprintf_long(char *bf, size_t size, struct syscall_arg *arg)
435{
436 return scnprintf(bf, size, "%ld", arg->val);
437}
438
729a7841
ACM		 439static const char *bpf_cmd[] = {
440 "MAP_CREATE", "MAP_LOOKUP_ELEM", "MAP_UPDATE_ELEM", "MAP_DELETE_ELEM",
441 "MAP_GET_NEXT_KEY", "PROG_LOAD",
442};
443static DEFINE_STRARRAY(bpf_cmd);
444
03e3adc9
ACM		 445static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
446static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
eac032c5 447
1f115cb7
ACM		 448static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
449static DEFINE_STRARRAY(itimers);
450
b62bee1b
ACM		 451static const char *keyctl_options[] = {
452 "GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
453 "SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
454 "INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
455 "ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
456 "INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
457};
458static DEFINE_STRARRAY(keyctl_options);
459
efe6b882
ACM		 460static const char *whences[] = { "SET", "CUR", "END",
461#ifdef SEEK_DATA
462"DATA",
463#endif
464#ifdef SEEK_HOLE
465"HOLE",
466#endif
467};
468static DEFINE_STRARRAY(whences);
f9da0b0c 469
80f587d5
ACM		 470static const char *fcntl_cmds[] = {
471 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
e000e5e3
ACM		 472 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "GETLK64",
473 "SETLK64", "SETLKW64", "SETOWN_EX", "GETOWN_EX",
474 "GETOWNER_UIDS",
80f587d5
ACM		 475};
476static DEFINE_STRARRAY(fcntl_cmds);
477
83a51694
ACM		 478static const char *fcntl_linux_specific_cmds[] = {
479 "SETLEASE", "GETLEASE", "NOTIFY", [5] = "CANCELLK", "DUPFD_CLOEXEC",
480 "SETPIPE_SZ", "GETPIPE_SZ", "ADD_SEALS", "GET_SEALS",
64e4561d 481 "GET_RW_HINT", "SET_RW_HINT", "GET_FILE_RW_HINT", "SET_FILE_RW_HINT",
83a51694
ACM		 482};
483
484static DEFINE_STRARRAY_OFFSET(fcntl_linux_specific_cmds, F_LINUX_SPECIFIC_BASE);
485
486static struct strarray *fcntl_cmds_arrays[] = {
487 &strarray__fcntl_cmds,
488 &strarray__fcntl_linux_specific_cmds,
489};
490
491static DEFINE_STRARRAYS(fcntl_cmds_arrays);
492
c045bf02
ACM		 493static const char *rlimit_resources[] = {
494 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
495 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
496 "RTTIME",
497};
498static DEFINE_STRARRAY(rlimit_resources);
499
eb5b1b14
ACM		 500static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
501static DEFINE_STRARRAY(sighow);
502
4f8c1b74
DA		 503static const char *clockid[] = {
504 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
28ebb87c
ACM		 505 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
506 "REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
4f8c1b74
DA		 507};
508static DEFINE_STRARRAY(clockid);
509
51108999
ACM		 510static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
511 struct syscall_arg *arg)
512{
513 size_t printed = 0;
514 int mode = arg->val;
515
516 if (mode == F_OK) /* 0 */
517 return scnprintf(bf, size, "F");
518#define P_MODE(n) \
519 if (mode & n##_OK) { \
520 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
521 mode &= ~n##_OK; \
522 }
523
524 P_MODE(R);
525 P_MODE(W);
526 P_MODE(X);
527#undef P_MODE
528
529 if (mode)
530 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
531
532 return printed;
533}
534
535#define SCA_ACCMODE syscall_arg__scnprintf_access_mode
536
f994592d
ACM		 537static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
538 struct syscall_arg *arg);
539
540#define SCA_FILENAME syscall_arg__scnprintf_filename
541
46cce19b
ACM		 542static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
543 struct syscall_arg *arg)
544{
545 int printed = 0, flags = arg->val;
546
547#define P_FLAG(n) \
548 if (flags & O_##n) { \
549 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
550 flags &= ~O_##n; \
551 }
552
553 P_FLAG(CLOEXEC);
554 P_FLAG(NONBLOCK);
555#undef P_FLAG
556
557 if (flags)
558 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
559
560 return printed;
561}
562
563#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
564
a355a61e
ACM		 565#ifndef GRND_NONBLOCK
566#define GRND_NONBLOCK 0x0001
567#endif
568#ifndef GRND_RANDOM
569#define GRND_RANDOM 0x0002
570#endif
571
39878d49
ACM		 572static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
573 struct syscall_arg *arg)
574{
575 int printed = 0, flags = arg->val;
576
577#define P_FLAG(n) \
578 if (flags & GRND_##n) { \
579 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
580 flags &= ~GRND_##n; \
581 }
582
583 P_FLAG(RANDOM);
584 P_FLAG(NONBLOCK);
585#undef P_FLAG
586
587 if (flags)
588 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
589
590 return printed;
591}
592
593#define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
594
82d4a110
ACM		 595#define STRARRAY(name, array) \
596 { .scnprintf = SCA_STRARRAY, \
597 .parm = &strarray__##array, }
453350dd 598
092bd3cd 599#include "trace/beauty/arch_errno_names.c"
ea8dc3ce 600#include "trace/beauty/eventfd.c"
d5d71e86 601#include "trace/beauty/futex_op.c"
3258abe0 602#include "trace/beauty/futex_val3.c"
df4cb167 603#include "trace/beauty/mmap.c"
ba2f22cf 604#include "trace/beauty/mode_t.c"
a30e6259 605#include "trace/beauty/msg_flags.c"
8f48df69 606#include "trace/beauty/open_flags.c"
62de344e 607#include "trace/beauty/perf_event_open.c"
d5d71e86 608#include "trace/beauty/pid.c"
a3bca91f 609#include "trace/beauty/sched_policy.c"
f5cd95ea 610#include "trace/beauty/seccomp.c"
12199d8e 611#include "trace/beauty/signum.c"
bbf86c43 612#include "trace/beauty/socket_type.c"
7206b900 613#include "trace/beauty/waitid_options.c"
a3bca91f 614
82d4a110
ACM		 615struct syscall_arg_fmt {
616 size_t (*scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
496fd346 617 unsigned long (*mask_val)(struct syscall_arg *arg, unsigned long val);
82d4a110 618 void *parm;
c51bdfec 619 const char *name;
d47737d5 620 bool show_zero;
82d4a110
ACM		 621};
622
514f1c67
ACM		 623static struct syscall_fmt {
624 const char *name;
aec1930b 625 const char *alias;
82d4a110 626 struct syscall_arg_fmt arg[6];
332337da 627 u8 nr_args;
11c8e39f 628 bool errpid;
514f1c67 629 bool timeout;
04b34729 630 bool hexret;
514f1c67 631} syscall_fmts[] = {
1f63139c 632 { .name = "access",
82d4a110 633 .arg = { [1] = { .scnprintf = SCA_ACCMODE, /* mode */ }, }, },
02ef2884
ACM		 634 { .name = "bind",
635 .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* umyaddr */ }, }, },
1f63139c 636 { .name = "bpf",
82d4a110 637 .arg = { [0] = STRARRAY(cmd, bpf_cmd), }, },
beccb2b5 638 { .name = "brk", .hexret = true,
82d4a110 639 .arg = { [0] = { .scnprintf = SCA_HEX, /* brk */ }, }, },
1f63139c 640 { .name = "clock_gettime",
82d4a110 641 .arg = { [0] = STRARRAY(clk_id, clockid), }, },
33396a3a
ACM		 642 { .name = "clone", .errpid = true, .nr_args = 5,
643 .arg = { [0] = { .name = "flags", .scnprintf = SCA_CLONE_FLAGS, },
644 [1] = { .name = "child_stack", .scnprintf = SCA_HEX, },
645 [2] = { .name = "parent_tidptr", .scnprintf = SCA_HEX, },
646 [3] = { .name = "child_tidptr", .scnprintf = SCA_HEX, },
647 [4] = { .name = "tls", .scnprintf = SCA_HEX, }, }, },
1f63139c 648 { .name = "close",
82d4a110 649 .arg = { [0] = { .scnprintf = SCA_CLOSE_FD, /* fd */ }, }, },
d5a7e661
ACM		 650 { .name = "connect",
651 .arg = { [1] = { .scnprintf = SCA_SOCKADDR, /* servaddr */ }, }, },
1f63139c 652 { .name = "epoll_ctl",
82d4a110 653 .arg = { [1] = STRARRAY(op, epoll_ctl_ops), }, },
1f63139c 654 { .name = "eventfd2",
82d4a110 655 .arg = { [1] = { .scnprintf = SCA_EFD_FLAGS, /* flags */ }, }, },
1f63139c 656 { .name = "fchmodat",
82d4a110 657 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 658 { .name = "fchownat",
82d4a110 659 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 660 { .name = "fcntl",
82d4a110 661 .arg = { [1] = { .scnprintf = SCA_FCNTL_CMD, /* cmd */
39cc355b
ACM		 662 .parm = &strarrays__fcntl_cmds_arrays,
663 .show_zero = true, },
82d4a110 664 [2] = { .scnprintf = SCA_FCNTL_ARG, /* arg */ }, }, },
1f63139c 665 { .name = "flock",
82d4a110 666 .arg = { [1] = { .scnprintf = SCA_FLOCK, /* cmd */ }, }, },
1f63139c
ACM		 667 { .name = "fstat", .alias = "newfstat", },
668 { .name = "fstatat", .alias = "newfstatat", },
669 { .name = "futex",
3258abe0
ACM		 670 .arg = { [1] = { .scnprintf = SCA_FUTEX_OP, /* op */ },
671 [5] = { .scnprintf = SCA_FUTEX_VAL3, /* val3 */ }, }, },
1f63139c 672 { .name = "futimesat",
82d4a110 673 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 674 { .name = "getitimer",
82d4a110 675 .arg = { [0] = STRARRAY(which, itimers), }, },
c65f1070 676 { .name = "getpid", .errpid = true, },
d1d438a3 677 { .name = "getpgid", .errpid = true, },
c65f1070 678 { .name = "getppid", .errpid = true, },
1f63139c 679 { .name = "getrandom",
82d4a110 680 .arg = { [2] = { .scnprintf = SCA_GETRANDOM_FLAGS, /* flags */ }, }, },
1f63139c 681 { .name = "getrlimit",
82d4a110 682 .arg = { [0] = STRARRAY(resource, rlimit_resources), }, },
2d1073de 683 { .name = "gettid", .errpid = true, },
1f63139c 684 { .name = "ioctl",
82d4a110 685 .arg = {
844ae5b4
ACM		 686#if defined(__i386__) || defined(__x86_64__)
687/*
688 * FIXME: Make this available to all arches.
689 */
1cc47f2d 690 [1] = { .scnprintf = SCA_IOCTL_CMD, /* cmd */ },
82d4a110 691 [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
844ae5b4 692#else
82d4a110 693 [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
844ae5b4 694#endif
1de3038d
ACM		 695 { .name = "kcmp", .nr_args = 5,
696 .arg = { [0] = { .name = "pid1", .scnprintf = SCA_PID, },
697 [1] = { .name = "pid2", .scnprintf = SCA_PID, },
698 [2] = { .name = "type", .scnprintf = SCA_KCMP_TYPE, },
699 [3] = { .name = "idx1", .scnprintf = SCA_KCMP_IDX, },
700 [4] = { .name = "idx2", .scnprintf = SCA_KCMP_IDX, }, }, },
1f63139c 701 { .name = "keyctl",
82d4a110 702 .arg = { [0] = STRARRAY(option, keyctl_options), }, },
1f63139c 703 { .name = "kill",
82d4a110 704 .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1f63139c 705 { .name = "linkat",
82d4a110 706 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 707 { .name = "lseek",
82d4a110 708 .arg = { [2] = STRARRAY(whence, whences), }, },
1f63139c
ACM		 709 { .name = "lstat", .alias = "newlstat", },
710 { .name = "madvise",
82d4a110
ACM		 711 .arg = { [0] = { .scnprintf = SCA_HEX, /* start */ },
712 [2] = { .scnprintf = SCA_MADV_BHV, /* behavior */ }, }, },
1f63139c 713 { .name = "mkdirat",
82d4a110 714 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 715 { .name = "mknodat",
82d4a110 716 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1f63139c 717 { .name = "mlock",
82d4a110 718 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
1f63139c 719 { .name = "mlockall",
82d4a110 720 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
beccb2b5 721 { .name = "mmap", .hexret = true,
54265664
JO		 722/* The standard mmap maps to old_mmap on s390x */
723#if defined(__s390x__)
724 .alias = "old_mmap",
725#endif
82d4a110
ACM		 726 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ },
727 [2] = { .scnprintf = SCA_MMAP_PROT, /* prot */ },
728 [3] = { .scnprintf = SCA_MMAP_FLAGS, /* flags */ }, }, },
73d141ad 729 { .name = "mount",
23c07a23
ACM		 730 .arg = { [0] = { .scnprintf = SCA_FILENAME, /* dev_name */ },
731 [3] = { .scnprintf = SCA_MOUNT_FLAGS, /* flags */
73d141ad 732 .mask_val = SCAMV_MOUNT_FLAGS, /* flags */ }, }, },
1f63139c 733 { .name = "mprotect",
82d4a110
ACM		 734 .arg = { [0] = { .scnprintf = SCA_HEX, /* start */ },
735 [2] = { .scnprintf = SCA_MMAP_PROT, /* prot */ }, }, },
1f63139c 736 { .name = "mq_unlink",
82d4a110 737 .arg = { [0] = { .scnprintf = SCA_FILENAME, /* u_name */ }, }, },
ae685380 738 { .name = "mremap", .hexret = true,
82d4a110
ACM		 739 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ },
740 [3] = { .scnprintf = SCA_MREMAP_FLAGS, /* flags */ },
741 [4] = { .scnprintf = SCA_HEX, /* new_addr */ }, }, },
1f63139c 742 { .name = "munlock",
82d4a110 743 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
1f63139c 744 { .name = "munmap",
82d4a110 745 .arg = { [0] = { .scnprintf = SCA_HEX, /* addr */ }, }, },
1f63139c 746 { .name = "name_to_handle_at",
82d4a110 747 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 748 { .name = "newfstatat",
82d4a110 749 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 750 { .name = "open",
82d4a110 751 .arg = { [1] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1f63139c 752 { .name = "open_by_handle_at",
82d4a110
ACM		 753 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ },
754 [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1f63139c 755 { .name = "openat",
82d4a110
ACM		 756 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ },
757 [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1f63139c 758 { .name = "perf_event_open",
82d4a110
ACM		 759 .arg = { [2] = { .scnprintf = SCA_INT, /* cpu */ },
760 [3] = { .scnprintf = SCA_FD, /* group_fd */ },
761 [4] = { .scnprintf = SCA_PERF_FLAGS, /* flags */ }, }, },
1f63139c 762 { .name = "pipe2",
82d4a110 763 .arg = { [1] = { .scnprintf = SCA_PIPE_FLAGS, /* flags */ }, }, },
83bc9c37
ACM		 764 { .name = "pkey_alloc",
765 .arg = { [1] = { .scnprintf = SCA_PKEY_ALLOC_ACCESS_RIGHTS, /* access_rights */ }, }, },
766 { .name = "pkey_free",
767 .arg = { [0] = { .scnprintf = SCA_INT, /* key */ }, }, },
768 { .name = "pkey_mprotect",
769 .arg = { [0] = { .scnprintf = SCA_HEX, /* start */ },
770 [2] = { .scnprintf = SCA_MMAP_PROT, /* prot */ },
771 [3] = { .scnprintf = SCA_INT, /* pkey */ }, }, },
1f63139c
ACM		 772 { .name = "poll", .timeout = true, },
773 { .name = "ppoll", .timeout = true, },
d688d037
ACM		 774 { .name = "prctl", .alias = "arch_prctl",
775 .arg = { [0] = { .scnprintf = SCA_PRCTL_OPTION, /* option */ },
776 [1] = { .scnprintf = SCA_PRCTL_ARG2, /* arg2 */ },
777 [2] = { .scnprintf = SCA_PRCTL_ARG3, /* arg3 */ }, }, },
1f63139c
ACM		 778 { .name = "pread", .alias = "pread64", },
779 { .name = "preadv", .alias = "pread", },
780 { .name = "prlimit64",
82d4a110 781 .arg = { [1] = STRARRAY(resource, rlimit_resources), }, },
1f63139c
ACM		 782 { .name = "pwrite", .alias = "pwrite64", },
783 { .name = "readlinkat",
82d4a110 784 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 785 { .name = "recvfrom",
82d4a110 786 .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1f63139c 787 { .name = "recvmmsg",
82d4a110 788 .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1f63139c 789 { .name = "recvmsg",
82d4a110 790 .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1f63139c 791 { .name = "renameat",
82d4a110 792 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 793 { .name = "rt_sigaction",
82d4a110 794 .arg = { [0] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1f63139c 795 { .name = "rt_sigprocmask",
82d4a110 796 .arg = { [0] = STRARRAY(how, sighow), }, },
1f63139c 797 { .name = "rt_sigqueueinfo",
82d4a110 798 .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1f63139c 799 { .name = "rt_tgsigqueueinfo",
82d4a110 800 .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1f63139c 801 { .name = "sched_setscheduler",
82d4a110 802 .arg = { [1] = { .scnprintf = SCA_SCHED_POLICY, /* policy */ }, }, },
1f63139c 803 { .name = "seccomp",
82d4a110
ACM		 804 .arg = { [0] = { .scnprintf = SCA_SECCOMP_OP, /* op */ },
805 [1] = { .scnprintf = SCA_SECCOMP_FLAGS, /* flags */ }, }, },
1f63139c
ACM		 806 { .name = "select", .timeout = true, },
807 { .name = "sendmmsg",
82d4a110 808 .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1f63139c 809 { .name = "sendmsg",
82d4a110 810 .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1f63139c 811 { .name = "sendto",
6ebb6862
ACM		 812 .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ },
813 [4] = { .scnprintf = SCA_SOCKADDR, /* addr */ }, }, },
c65f1070 814 { .name = "set_tid_address", .errpid = true, },
1f63139c 815 { .name = "setitimer",
82d4a110 816 .arg = { [0] = STRARRAY(which, itimers), }, },
1f63139c 817 { .name = "setrlimit",
82d4a110 818 .arg = { [0] = STRARRAY(resource, rlimit_resources), }, },
1f63139c 819 { .name = "socket",
82d4a110 820 .arg = { [0] = STRARRAY(family, socket_families),
162d3edb
ACM		 821 [1] = { .scnprintf = SCA_SK_TYPE, /* type */ },
822 [2] = { .scnprintf = SCA_SK_PROTO, /* protocol */ }, }, },
1f63139c 823 { .name = "socketpair",
82d4a110 824 .arg = { [0] = STRARRAY(family, socket_families),
162d3edb
ACM		 825 [1] = { .scnprintf = SCA_SK_TYPE, /* type */ },
826 [2] = { .scnprintf = SCA_SK_PROTO, /* protocol */ }, }, },
1f63139c
ACM		 827 { .name = "stat", .alias = "newstat", },
828 { .name = "statx",
82d4a110
ACM		 829 .arg = { [0] = { .scnprintf = SCA_FDAT, /* fdat */ },
830 [2] = { .scnprintf = SCA_STATX_FLAGS, /* flags */ } ,
831 [3] = { .scnprintf = SCA_STATX_MASK, /* mask */ }, }, },
1f63139c 832 { .name = "swapoff",
82d4a110 833 .arg = { [0] = { .scnprintf = SCA_FILENAME, /* specialfile */ }, }, },
1f63139c 834 { .name = "swapon",
82d4a110 835 .arg = { [0] = { .scnprintf = SCA_FILENAME, /* specialfile */ }, }, },
1f63139c 836 { .name = "symlinkat",
82d4a110 837 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 838 { .name = "tgkill",
82d4a110 839 .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1f63139c 840 { .name = "tkill",
82d4a110 841 .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
476c92ca
ACM		 842 { .name = "umount2", .alias = "umount",
843 .arg = { [0] = { .scnprintf = SCA_FILENAME, /* name */ }, }, },
1f63139c
ACM		 844 { .name = "uname", .alias = "newuname", },
845 { .name = "unlinkat",
82d4a110 846 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1f63139c 847 { .name = "utimensat",
82d4a110 848 .arg = { [0] = { .scnprintf = SCA_FDAT, /* dirfd */ }, }, },
11c8e39f 849 { .name = "wait4", .errpid = true,
82d4a110 850 .arg = { [2] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
11c8e39f 851 { .name = "waitid", .errpid = true,
82d4a110 852 .arg = { [3] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
514f1c67
ACM		 853};
854
855static int syscall_fmt__cmp(const void *name, const void *fmtp)
856{
857 const struct syscall_fmt *fmt = fmtp;
858 return strcmp(name, fmt->name);
859}
860
861static struct syscall_fmt *syscall_fmt__find(const char *name)
862{
863 const int nmemb = ARRAY_SIZE(syscall_fmts);
864 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
865}
866
f932184e
ACM		 867static struct syscall_fmt *syscall_fmt__find_by_alias(const char *alias)
868{
869 int i, nmemb = ARRAY_SIZE(syscall_fmts);
870
871 for (i = 0; i < nmemb; ++i) {
872 if (syscall_fmts[i].alias && strcmp(syscall_fmts[i].alias, alias) == 0)
873 return &syscall_fmts[i];
874 }
875
876 return NULL;
877}
878
6a648b53
ACM		 879/*
880 * is_exit: is this "exit" or "exit_group"?
881 * is_open: is this "open" or "openat"? To associate the fd returned in sys_exit with the pathname in sys_enter.
7a983a0f 882 * args_size: sum of the sizes of the syscall arguments, anything after that is augmented stuff: pathname for openat, etc.
6a648b53 883 */
514f1c67 884struct syscall {
4963b0f8 885 struct tep_event_format *tp_format;
f208bd8d 886 int nr_args;
7a983a0f 887 int args_size;
6a648b53
ACM		 888 bool is_exit;
889 bool is_open;
2c92f982 890 struct tep_format_field *args;
514f1c67
ACM		 891 const char *name;
892 struct syscall_fmt *fmt;
82d4a110 893 struct syscall_arg_fmt *arg_fmt;
514f1c67
ACM		 894};
895
fd2b2975
ACM		 896/*
897 * We need to have this 'calculated' boolean because in some cases we really
898 * don't know what is the duration of a syscall, for instance, when we start
899 * a session and some threads are waiting for a syscall to finish, say 'poll',
900 * in which case all we can do is to print "( ? ) for duration and for the
901 * start timestamp.
902 */
903static size_t fprintf_duration(unsigned long t, bool calculated, FILE *fp)
60c907ab
ACM		 904{
905 double duration = (double)t / NSEC_PER_MSEC;
906 size_t printed = fprintf(fp, "(");
907
fd2b2975 908 if (!calculated)
522283fe 909 printed += fprintf(fp, " ");
fd2b2975 910 else if (duration >= 1.0)
60c907ab
ACM		 911 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
912 else if (duration >= 0.01)
913 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
914 else
915 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
c24ff998 916 return printed + fprintf(fp, "): ");
60c907ab
ACM		 917}
918
f994592d
ACM		 919/**
920 * filename.ptr: The filename char pointer that will be vfs_getname'd
921 * filename.entry_str_pos: Where to insert the string translated from
922 * filename.ptr by the vfs_getname tracepoint/kprobe.
84486caa
ACM		 923 * ret_scnprintf: syscall args may set this to a different syscall return
924 * formatter, for instance, fcntl may return fds, file flags, etc.
f994592d 925 */
752fde44
ACM		 926struct thread_trace {
927 u64 entry_time;
752fde44 928 bool entry_pending;
efd5745e 929 unsigned long nr_events;
a2ea67d7 930 unsigned long pfmaj, pfmin;
752fde44 931 char *entry_str;
1302d88e 932 double runtime_ms;
7ee57434 933 size_t (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
f994592d
ACM		 934 struct {
935 unsigned long ptr;
7f4f8001
ACM		 936 short int entry_str_pos;
937 bool pending_open;
938 unsigned int namelen;
939 char *name;
f994592d 940 } filename;
75b757ca
ACM		 941 struct {
942 int max;
943 char **table;
944 } paths;
bf2575c1
DA		 945
946 struct intlist *syscall_stats;
752fde44
ACM		 947};
948
949static struct thread_trace *thread_trace__new(void)
950{
75b757ca
ACM		 951 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
952
953 if (ttrace)
954 ttrace->paths.max = -1;
955
bf2575c1
DA		 956 ttrace->syscall_stats = intlist__new(NULL);
957
75b757ca 958 return ttrace;
752fde44
ACM		 959}
960
c24ff998 961static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
752fde44 962{
efd5745e
ACM		 963 struct thread_trace *ttrace;
964
752fde44
ACM		 965 if (thread == NULL)
966 goto fail;
967
89dceb22
NK		 968 if (thread__priv(thread) == NULL)
969 thread__set_priv(thread, thread_trace__new());
48000a1a 970
89dceb22 971 if (thread__priv(thread) == NULL)
752fde44
ACM		 972 goto fail;
973
89dceb22 974 ttrace = thread__priv(thread);
efd5745e
ACM		 975 ++ttrace->nr_events;
976
977 return ttrace;
752fde44 978fail:
c24ff998 979 color_fprintf(fp, PERF_COLOR_RED,
752fde44
ACM		 980 "WARNING: not enough memory, dropping samples!\n");
981 return NULL;
982}
983
84486caa
ACM		 984
985void syscall_arg__set_ret_scnprintf(struct syscall_arg *arg,
7ee57434 986 size_t (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg))
84486caa
ACM		 987{
988 struct thread_trace *ttrace = thread__priv(arg->thread);
989
990 ttrace->ret_scnprintf = ret_scnprintf;
991}
992
598d02c5
SF		 993#define TRACE_PFMAJ (1 << 0)
994#define TRACE_PFMIN (1 << 1)
995
e4d44e83
ACM		 996static const size_t trace__entry_str_size = 2048;
997
97119f37 998static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
75b757ca 999{
89dceb22 1000 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1001
1002 if (fd > ttrace->paths.max) {
1003 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1004
1005 if (npath == NULL)
1006 return -1;
1007
1008 if (ttrace->paths.max != -1) {
1009 memset(npath + ttrace->paths.max + 1, 0,
1010 (fd - ttrace->paths.max) * sizeof(char *));
1011 } else {
1012 memset(npath, 0, (fd + 1) * sizeof(char *));
1013 }
1014
1015 ttrace->paths.table = npath;
1016 ttrace->paths.max = fd;
1017 }
1018
1019 ttrace->paths.table[fd] = strdup(pathname);
1020
1021 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1022}
1023
97119f37
ACM		 1024static int thread__read_fd_path(struct thread *thread, int fd)
1025{
1026 char linkname[PATH_MAX], pathname[PATH_MAX];
1027 struct stat st;
1028 int ret;
1029
1030 if (thread->pid_ == thread->tid) {
1031 scnprintf(linkname, sizeof(linkname),
1032 "/proc/%d/fd/%d", thread->pid_, fd);
1033 } else {
1034 scnprintf(linkname, sizeof(linkname),
1035 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1036 }
1037
1038 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1039 return -1;
1040
1041 ret = readlink(linkname, pathname, sizeof(pathname));
1042
1043 if (ret < 0 || ret > st.st_size)
1044 return -1;
1045
1046 pathname[ret] = '\0';
1047 return trace__set_fd_pathname(thread, fd, pathname);
1048}
1049
c522739d
ACM		 1050static const char *thread__fd_path(struct thread *thread, int fd,
1051 struct trace *trace)
75b757ca 1052{
89dceb22 1053 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1054
1055 if (ttrace == NULL)
1056 return NULL;
1057
1058 if (fd < 0)
1059 return NULL;
1060
cdcd1e6b 1061 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
c522739d
ACM		 1062 if (!trace->live)
1063 return NULL;
1064 ++trace->stats.proc_getname;
cdcd1e6b 1065 if (thread__read_fd_path(thread, fd))
c522739d
ACM		 1066 return NULL;
1067 }
75b757ca
ACM		 1068
1069 return ttrace->paths.table[fd];
1070}
1071
fc65eb82 1072size_t syscall_arg__scnprintf_fd(char *bf, size_t size, struct syscall_arg *arg)
75b757ca
ACM		 1073{
1074 int fd = arg->val;
1075 size_t printed = scnprintf(bf, size, "%d", fd);
c522739d 1076 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
75b757ca
ACM		 1077
1078 if (path)
1079 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1080
1081 return printed;
1082}
1083
0a2f7540
ACM		 1084size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size)
1085{
1086 size_t printed = scnprintf(bf, size, "%d", fd);
1087 struct thread *thread = machine__find_thread(trace->host, pid, pid);
1088
1089 if (thread) {
1090 const char *path = thread__fd_path(thread, fd, trace);
1091
1092 if (path)
1093 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1094
1095 thread__put(thread);
1096 }
1097
1098 return printed;
1099}
1100
75b757ca
ACM		 1101static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1102 struct syscall_arg *arg)
1103{
1104 int fd = arg->val;
1105 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
89dceb22 1106 struct thread_trace *ttrace = thread__priv(arg->thread);
75b757ca 1107
04662523
ACM		 1108 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1109 zfree(&ttrace->paths.table[fd]);
75b757ca
ACM		 1110
1111 return printed;
1112}
1113
f994592d
ACM		 1114static void thread__set_filename_pos(struct thread *thread, const char *bf,
1115 unsigned long ptr)
1116{
1117 struct thread_trace *ttrace = thread__priv(thread);
1118
1119 ttrace->filename.ptr = ptr;
1120 ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1121}
1122
75d1e306
ACM		 1123static size_t syscall_arg__scnprintf_augmented_string(struct syscall_arg *arg, char *bf, size_t size)
1124{
1125 struct augmented_arg *augmented_arg = arg->augmented.args;
1126
1127 return scnprintf(bf, size, "%.*s", augmented_arg->size, augmented_arg->value);
1128}
1129
f994592d
ACM		 1130static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1131 struct syscall_arg *arg)
1132{
1133 unsigned long ptr = arg->val;
1134
75d1e306
ACM		 1135 if (arg->augmented.args)
1136 return syscall_arg__scnprintf_augmented_string(arg, bf, size);
1137
f994592d
ACM		 1138 if (!arg->trace->vfs_getname)
1139 return scnprintf(bf, size, "%#x", ptr);
1140
1141 thread__set_filename_pos(arg->thread, bf, ptr);
1142 return 0;
1143}
1144
ae9ed035
ACM		 1145static bool trace__filter_duration(struct trace *trace, double t)
1146{
1147 return t < (trace->duration_filter * NSEC_PER_MSEC);
1148}
1149
fd2b2975 1150static size_t __trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
752fde44
ACM		 1151{
1152 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1153
60c907ab 1154 return fprintf(fp, "%10.3f ", ts);
752fde44
ACM		 1155}
1156
fd2b2975
ACM		 1157/*
1158 * We're handling tstamp=0 as an undefined tstamp, i.e. like when we are
1159 * using ttrace->entry_time for a thread that receives a sys_exit without
1160 * first having received a sys_enter ("poll" issued before tracing session
1161 * starts, lost sys_enter exit due to ring buffer overflow).
1162 */
1163static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1164{
1165 if (tstamp > 0)
1166 return __trace__fprintf_tstamp(trace, tstamp, fp);
1167
1168 return fprintf(fp, " ? ");
1169}
1170
f15eb531 1171static bool done = false;
ba209f85 1172static bool interrupted = false;
f15eb531 1173
ba209f85 1174static void sig_handler(int sig)
f15eb531
NK		 1175{
1176 done = true;
ba209f85 1177 interrupted = sig == SIGINT;
f15eb531
NK		 1178}
1179
6dcbd212 1180static size_t trace__fprintf_comm_tid(struct trace *trace, struct thread *thread, FILE *fp)
752fde44 1181{
6dcbd212 1182 size_t printed = 0;
752fde44 1183
50c95cbd
ACM		 1184 if (trace->multiple_threads) {
1185 if (trace->show_comm)
1902efe7 1186 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
38051234 1187 printed += fprintf(fp, "%d ", thread->tid);
50c95cbd 1188 }
752fde44
ACM		 1189
1190 return printed;
1191}
1192
6dcbd212
ACM		 1193static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1194 u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
1195{
1196 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1197 printed += fprintf_duration(duration, duration_calculated, fp);
1198 return printed + trace__fprintf_comm_tid(trace, thread, fp);
1199}
1200
c24ff998 1201static int trace__process_event(struct trace *trace, struct machine *machine,
162f0bef 1202 union perf_event *event, struct perf_sample *sample)
752fde44
ACM		 1203{
1204 int ret = 0;
1205
1206 switch (event->header.type) {
1207 case PERF_RECORD_LOST:
c24ff998 1208 color_fprintf(trace->output, PERF_COLOR_RED,
752fde44 1209 "LOST %" PRIu64 " events!\n", event->lost.lost);
162f0bef 1210 ret = machine__process_lost_event(machine, event, sample);
3ed5ca2e 1211 break;
752fde44 1212 default:
162f0bef 1213 ret = machine__process_event(machine, event, sample);
752fde44
ACM		 1214 break;
1215 }
1216
1217 return ret;
1218}
1219
c24ff998 1220static int trace__tool_process(struct perf_tool *tool,
752fde44 1221 union perf_event *event,
162f0bef 1222 struct perf_sample *sample,
752fde44
ACM		 1223 struct machine *machine)
1224{
c24ff998 1225 struct trace *trace = container_of(tool, struct trace, tool);
162f0bef 1226 return trace__process_event(trace, machine, event, sample);
752fde44
ACM		 1227}
1228
caf8a0d0
ACM		 1229static char *trace__machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp)
1230{
1231 struct machine *machine = vmachine;
1232
1233 if (machine->kptr_restrict_warned)
1234 return NULL;
1235
1236 if (symbol_conf.kptr_restrict) {
1237 pr_warning("Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
1238 "Check /proc/sys/kernel/kptr_restrict.\n\n"
1239 "Kernel samples will not be resolved.\n");
1240 machine->kptr_restrict_warned = true;
1241 return NULL;
1242 }
1243
1244 return machine__resolve_kernel_addr(vmachine, addrp, modp);
1245}
1246
752fde44
ACM		 1247static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1248{
0a7e6d1b 1249 int err = symbol__init(NULL);
752fde44
ACM		 1250
1251 if (err)
1252 return err;
1253
8fb598e5
DA		 1254 trace->host = machine__new_host();
1255 if (trace->host == NULL)
1256 return -ENOMEM;
752fde44 1257
cbd5c178
AV		 1258 err = trace_event__register_resolver(trace->host, trace__machine__resolve_kernel_addr);
1259 if (err < 0)
1260 goto out;
706c3da4 1261
a33fbd56 1262 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
9d9cad76 1263 evlist->threads, trace__tool_process, false,
340b47f5 1264 trace->opts.proc_map_timeout, 1);
cbd5c178 1265out:
752fde44
ACM		 1266 if (err)
1267 symbol__exit();
1268
1269 return err;
1270}
1271
33974a41
AV		 1272static void trace__symbols__exit(struct trace *trace)
1273{
1274 machine__exit(trace->host);
1275 trace->host = NULL;
1276
1277 symbol__exit();
1278}
1279
5e58fcfa 1280static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
13d4ff3e 1281{
5e58fcfa 1282 int idx;
13d4ff3e 1283
332337da
ACM		 1284 if (nr_args == 6 && sc->fmt && sc->fmt->nr_args != 0)
1285 nr_args = sc->fmt->nr_args;
1286
5e58fcfa 1287 sc->arg_fmt = calloc(nr_args, sizeof(*sc->arg_fmt));
82d4a110 1288 if (sc->arg_fmt == NULL)
13d4ff3e
ACM		 1289 return -1;
1290
5e58fcfa
ACM		 1291 for (idx = 0; idx < nr_args; ++idx) {
1292 if (sc->fmt)
82d4a110 1293 sc->arg_fmt[idx] = sc->fmt->arg[idx];
5e58fcfa 1294 }
82d4a110 1295
5e58fcfa
ACM		 1296 sc->nr_args = nr_args;
1297 return 0;
1298}
1299
1300static int syscall__set_arg_fmts(struct syscall *sc)
1301{
2c92f982 1302 struct tep_format_field *field, *last_field = NULL;
5e58fcfa
ACM		 1303 int idx = 0, len;
1304
1305 for (field = sc->args; field; field = field->next, ++idx) {
7a983a0f
ACM		 1306 last_field = field;
1307
5e58fcfa
ACM		 1308 if (sc->fmt && sc->fmt->arg[idx].scnprintf)
1309 continue;
1f115cb7 1310
82d4a110 1311 if (strcmp(field->type, "const char *") == 0 &&
12f3ca4f
ACM		 1312 (strcmp(field->name, "filename") == 0 ||
1313 strcmp(field->name, "path") == 0 ||
1314 strcmp(field->name, "pathname") == 0))
82d4a110 1315 sc->arg_fmt[idx].scnprintf = SCA_FILENAME;
bb39ccb2 1316 else if (field->flags & TEP_FIELD_IS_POINTER)
82d4a110 1317 sc->arg_fmt[idx].scnprintf = syscall_arg__scnprintf_hex;
d1d438a3 1318 else if (strcmp(field->type, "pid_t") == 0)
82d4a110 1319 sc->arg_fmt[idx].scnprintf = SCA_PID;
ba2f22cf 1320 else if (strcmp(field->type, "umode_t") == 0)
82d4a110 1321 sc->arg_fmt[idx].scnprintf = SCA_MODE_T;
b6565c90
ACM		 1322 else if ((strcmp(field->type, "int") == 0 ||
1323 strcmp(field->type, "unsigned int") == 0 ||
1324 strcmp(field->type, "long") == 0) &&
1325 (len = strlen(field->name)) >= 2 &&
1326 strcmp(field->name + len - 2, "fd") == 0) {
1327 /*
1328 * /sys/kernel/tracing/events/syscalls/sys_enter*
1329 * egrep 'field:.*fd;' .../format|sed -r 's/.*field:([a-z ]+) [a-z_]*fd.+/\1/g'|sort|uniq -c
1330 * 65 int
1331 * 23 unsigned int
1332 * 7 unsigned long
1333 */
82d4a110 1334 sc->arg_fmt[idx].scnprintf = SCA_FD;
b6565c90 1335 }
13d4ff3e
ACM		 1336 }
1337
7a983a0f
ACM		 1338 if (last_field)
1339 sc->args_size = last_field->offset + last_field->size;
1340
13d4ff3e
ACM		 1341 return 0;
1342}
1343
514f1c67
ACM		 1344static int trace__read_syscall_info(struct trace *trace, int id)
1345{
1346 char tp_name[128];
1347 struct syscall *sc;
fd0db102 1348 const char *name = syscalltbl__name(trace->sctbl, id);
3a531260
ACM		 1349
1350 if (name == NULL)
1351 return -1;
514f1c67
ACM		 1352
1353 if (id > trace->syscalls.max) {
1354 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1355
1356 if (nsyscalls == NULL)
1357 return -1;
1358
1359 if (trace->syscalls.max != -1) {
1360 memset(nsyscalls + trace->syscalls.max + 1, 0,
1361 (id - trace->syscalls.max) * sizeof(*sc));
1362 } else {
1363 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1364 }
1365
1366 trace->syscalls.table = nsyscalls;
1367 trace->syscalls.max = id;
1368 }
1369
1370 sc = trace->syscalls.table + id;
3a531260 1371 sc->name = name;
2ae3a312 1372
3a531260 1373 sc->fmt = syscall_fmt__find(sc->name);
514f1c67 1374
aec1930b 1375 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
97978b3e 1376 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b 1377
8dd2a131 1378 if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
aec1930b 1379 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
97978b3e 1380 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b 1381 }
514f1c67 1382
5e58fcfa
ACM		 1383 if (syscall__alloc_arg_fmts(sc, IS_ERR(sc->tp_format) ? 6 : sc->tp_format->format.nr_fields))
1384 return -1;
1385
8dd2a131 1386 if (IS_ERR(sc->tp_format))
13d4ff3e
ACM		 1387 return -1;
1388
f208bd8d 1389 sc->args = sc->tp_format->format.fields;
c42de706
TS		 1390 /*
1391 * We need to check and discard the first variable '__syscall_nr'
1392 * or 'nr' that mean the syscall number. It is needless here.
1393 * So drop '__syscall_nr' or 'nr' field but does not exist on older kernels.
1394 */
1395 if (sc->args && (!strcmp(sc->args->name, "__syscall_nr") || !strcmp(sc->args->name, "nr"))) {
f208bd8d
ACM		 1396 sc->args = sc->args->next;
1397 --sc->nr_args;
1398 }
1399
5089f20e 1400 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
6a648b53 1401 sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
5089f20e 1402
13d4ff3e 1403 return syscall__set_arg_fmts(sc);
514f1c67
ACM		 1404}
1405
d0cc439b
ACM		 1406static int trace__validate_ev_qualifier(struct trace *trace)
1407{
8b3ce757 1408 int err = 0, i;
27702bcf 1409 size_t nr_allocated;
d0cc439b
ACM		 1410 struct str_node *pos;
1411
8b3ce757
ACM		 1412 trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1413 trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1414 sizeof(trace->ev_qualifier_ids.entries[0]));
1415
1416 if (trace->ev_qualifier_ids.entries == NULL) {
1417 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1418 trace->output);
1419 err = -EINVAL;
1420 goto out;
1421 }
1422
27702bcf 1423 nr_allocated = trace->ev_qualifier_ids.nr;
8b3ce757
ACM		 1424 i = 0;
1425
602a1f4d 1426 strlist__for_each_entry(pos, trace->ev_qualifier) {
d0cc439b 1427 const char *sc = pos->s;
27702bcf 1428 int id = syscalltbl__id(trace->sctbl, sc), match_next = -1;
d0cc439b 1429
8b3ce757 1430 if (id < 0) {
27702bcf
ACM		 1431 id = syscalltbl__strglobmatch_first(trace->sctbl, sc, &match_next);
1432 if (id >= 0)
1433 goto matches;
1434
d0cc439b
ACM		 1435 if (err == 0) {
1436 fputs("Error:\tInvalid syscall ", trace->output);
1437 err = -EINVAL;
1438 } else {
1439 fputs(", ", trace->output);
1440 }
1441
1442 fputs(sc, trace->output);
1443 }
27702bcf 1444matches:
8b3ce757 1445 trace->ev_qualifier_ids.entries[i++] = id;
27702bcf
ACM		 1446 if (match_next == -1)
1447 continue;
1448
1449 while (1) {
1450 id = syscalltbl__strglobmatch_next(trace->sctbl, sc, &match_next);
1451 if (id < 0)
1452 break;
1453 if (nr_allocated == trace->ev_qualifier_ids.nr) {
1454 void *entries;
1455
1456 nr_allocated += 8;
1457 entries = realloc(trace->ev_qualifier_ids.entries,
1458 nr_allocated * sizeof(trace->ev_qualifier_ids.entries[0]));
1459 if (entries == NULL) {
1460 err = -ENOMEM;
1461 fputs("\nError:\t Not enough memory for parsing\n", trace->output);
1462 goto out_free;
1463 }
1464 trace->ev_qualifier_ids.entries = entries;
1465 }
1466 trace->ev_qualifier_ids.nr++;
1467 trace->ev_qualifier_ids.entries[i++] = id;
1468 }
d0cc439b
ACM		 1469 }
1470
1471 if (err < 0) {
1472 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1473 "\nHint:\tand: 'man syscalls'\n", trace->output);
27702bcf 1474out_free:
8b3ce757
ACM		 1475 zfree(&trace->ev_qualifier_ids.entries);
1476 trace->ev_qualifier_ids.nr = 0;
d0cc439b 1477 }
8b3ce757 1478out:
d0cc439b
ACM		 1479 return err;
1480}
1481
55d43bca
DA		 1482/*
1483 * args is to be interpreted as a series of longs but we need to handle
1484 * 8-byte unaligned accesses. args points to raw_data within the event
1485 * and raw_data is guaranteed to be 8-byte unaligned because it is
1486 * preceded by raw_size which is a u32. So we need to copy args to a temp
1487 * variable to read it. Most notably this avoids extended load instructions
1488 * on unaligned addresses
1489 */
325f5091 1490unsigned long syscall_arg__val(struct syscall_arg *arg, u8 idx)
f9f83b33
ACM		 1491{
1492 unsigned long val;
325f5091 1493 unsigned char *p = arg->args + sizeof(unsigned long) * idx;
f9f83b33
ACM		 1494
1495 memcpy(&val, p, sizeof(val));
1496 return val;
1497}
1498
c51bdfec
ACM		 1499static size_t syscall__scnprintf_name(struct syscall *sc, char *bf, size_t size,
1500 struct syscall_arg *arg)
1501{
1502 if (sc->arg_fmt && sc->arg_fmt[arg->idx].name)
1503 return scnprintf(bf, size, "%s: ", sc->arg_fmt[arg->idx].name);
1504
1505 return scnprintf(bf, size, "arg%d: ", arg->idx);
1506}
1507
496fd346
ACM		 1508/*
1509 * Check if the value is in fact zero, i.e. mask whatever needs masking, such
1510 * as mount 'flags' argument that needs ignoring some magic flag, see comment
1511 * in tools/perf/trace/beauty/mount_flags.c
1512 */
1513static unsigned long syscall__mask_val(struct syscall *sc, struct syscall_arg *arg, unsigned long val)
1514{
1515 if (sc->arg_fmt && sc->arg_fmt[arg->idx].mask_val)
1516 return sc->arg_fmt[arg->idx].mask_val(arg, val);
1517
1518 return val;
1519}
1520
d032d79e
ACM		 1521static size_t syscall__scnprintf_val(struct syscall *sc, char *bf, size_t size,
1522 struct syscall_arg *arg, unsigned long val)
1523{
1524 if (sc->arg_fmt && sc->arg_fmt[arg->idx].scnprintf) {
1525 arg->val = val;
1526 if (sc->arg_fmt[arg->idx].parm)
1527 arg->parm = sc->arg_fmt[arg->idx].parm;
1528 return sc->arg_fmt[arg->idx].scnprintf(bf, size, arg);
1529 }
1530 return scnprintf(bf, size, "%ld", val);
1531}
1532
752fde44 1533static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
7a983a0f
ACM		 1534 unsigned char *args, void *augmented_args, int augmented_args_size,
1535 struct trace *trace, struct thread *thread)
514f1c67 1536{
514f1c67 1537 size_t printed = 0;
55d43bca 1538 unsigned long val;
d032d79e
ACM		 1539 u8 bit = 1;
1540 struct syscall_arg arg = {
1541 .args = args,
7a983a0f
ACM		 1542 .augmented = {
1543 .size = augmented_args_size,
1544 .args = augmented_args,
1545 },
d032d79e
ACM		 1546 .idx = 0,
1547 .mask = 0,
1548 .trace = trace,
1549 .thread = thread,
1550 };
84486caa
ACM		 1551 struct thread_trace *ttrace = thread__priv(thread);
1552
1553 /*
1554 * Things like fcntl will set this in its 'cmd' formatter to pick the
1555 * right formatter for the return value (an fd? file flags?), which is
1556 * not needed for syscalls that always return a given type, say an fd.
1557 */
1558 ttrace->ret_scnprintf = NULL;
514f1c67 1559
f208bd8d 1560 if (sc->args != NULL) {
2c92f982 1561 struct tep_format_field *field;
6e7eeb51 1562
f208bd8d 1563 for (field = sc->args; field;
01533e97
ACM		 1564 field = field->next, ++arg.idx, bit <<= 1) {
1565 if (arg.mask & bit)
6e7eeb51 1566 continue;
55d43bca 1567
f9f83b33 1568 val = syscall_arg__val(&arg, arg.idx);
496fd346
ACM		 1569 /*
1570 * Some syscall args need some mask, most don't and
1571 * return val untouched.
1572 */
1573 val = syscall__mask_val(sc, &arg, val);
55d43bca 1574
4aa58232
ACM		 1575 /*
1576 * Suppress this argument if its value is zero and
1577 * and we don't have a string associated in an
1578 * strarray for it.
1579 */
55d43bca 1580 if (val == 0 &&
82d4a110 1581 !(sc->arg_fmt &&
d47737d5
ACM		 1582 (sc->arg_fmt[arg.idx].show_zero ||
1583 sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAY ||
82d4a110
ACM		 1584 sc->arg_fmt[arg.idx].scnprintf == SCA_STRARRAYS) &&
1585 sc->arg_fmt[arg.idx].parm))
22ae5cf1
ACM		 1586 continue;
1587
752fde44 1588 printed += scnprintf(bf + printed, size - printed,
13d4ff3e 1589 "%s%s: ", printed ? ", " : "", field->name);
d032d79e 1590 printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
514f1c67 1591 }
4c4d6e51
ACM		 1592 } else if (IS_ERR(sc->tp_format)) {
1593 /*
1594 * If we managed to read the tracepoint /format file, then we
1595 * may end up not having any args, like with gettid(), so only
1596 * print the raw args when we didn't manage to read it.
1597 */
332337da 1598 while (arg.idx < sc->nr_args) {
d032d79e
ACM		 1599 if (arg.mask & bit)
1600 goto next_arg;
1601 val = syscall_arg__val(&arg, arg.idx);
c51bdfec
ACM		 1602 if (printed)
1603 printed += scnprintf(bf + printed, size - printed, ", ");
1604 printed += syscall__scnprintf_name(sc, bf + printed, size - printed, &arg);
d032d79e
ACM		 1605 printed += syscall__scnprintf_val(sc, bf + printed, size - printed, &arg, val);
1606next_arg:
1607 ++arg.idx;
1608 bit <<= 1;
514f1c67
ACM		 1609 }
1610 }
1611
1612 return printed;
1613}
1614
ba3d7dee 1615typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1616 union perf_event *event,
ba3d7dee
ACM		 1617 struct perf_sample *sample);
1618
1619static struct syscall *trace__syscall_info(struct trace *trace,
bf2575c1 1620 struct perf_evsel *evsel, int id)
ba3d7dee 1621{
ba3d7dee
ACM		 1622
1623 if (id < 0) {
adaa18bf
ACM		 1624
1625 /*
1626 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1627 * before that, leaving at a higher verbosity level till that is
1628 * explained. Reproduced with plain ftrace with:
1629 *
1630 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1631 * grep "NR -1 " /t/trace_pipe
1632 *
1633 * After generating some load on the machine.
1634 */
1635 if (verbose > 1) {
1636 static u64 n;
1637 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1638 id, perf_evsel__name(evsel), ++n);
1639 }
ba3d7dee
ACM		 1640 return NULL;
1641 }
1642
1643 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1644 trace__read_syscall_info(trace, id))
1645 goto out_cant_read;
1646
1647 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1648 goto out_cant_read;
1649
1650 return &trace->syscalls.table[id];
1651
1652out_cant_read:
bb963e16 1653 if (verbose > 0) {
7c304ee0
ACM		 1654 fprintf(trace->output, "Problems reading syscall %d", id);
1655 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1656 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1657 fputs(" information\n", trace->output);
1658 }
ba3d7dee
ACM		 1659 return NULL;
1660}
1661
bf2575c1
DA		 1662static void thread__update_stats(struct thread_trace *ttrace,
1663 int id, struct perf_sample *sample)
1664{
1665 struct int_node *inode;
1666 struct stats *stats;
1667 u64 duration = 0;
1668
1669 inode = intlist__findnew(ttrace->syscall_stats, id);
1670 if (inode == NULL)
1671 return;
1672
1673 stats = inode->priv;
1674 if (stats == NULL) {
1675 stats = malloc(sizeof(struct stats));
1676 if (stats == NULL)
1677 return;
1678 init_stats(stats);
1679 inode->priv = stats;
1680 }
1681
1682 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1683 duration = sample->time - ttrace->entry_time;
1684
1685 update_stats(stats, duration);
1686}
1687
522283fe 1688static int trace__printf_interrupted_entry(struct trace *trace)
e596663e
ACM		 1689{
1690 struct thread_trace *ttrace;
e596663e
ACM		 1691 size_t printed;
1692
0a6545bd 1693 if (trace->failure_only || trace->current == NULL)
e596663e
ACM		 1694 return 0;
1695
1696 ttrace = thread__priv(trace->current);
1697
1698 if (!ttrace->entry_pending)
1699 return 0;
1700
522283fe 1701 printed = trace__fprintf_entry_head(trace, trace->current, 0, false, ttrace->entry_time, trace->output);
e596663e
ACM		 1702 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1703 ttrace->entry_pending = false;
1704
5067a8cd
ACM		 1705 ++trace->nr_events_printed;
1706
e596663e
ACM		 1707 return printed;
1708}
1709
591421e1
ACM		 1710static int trace__fprintf_sample(struct trace *trace, struct perf_evsel *evsel,
1711 struct perf_sample *sample, struct thread *thread)
1712{
1713 int printed = 0;
1714
1715 if (trace->print_sample) {
1716 double ts = (double)sample->time / NSEC_PER_MSEC;
1717
1718 printed += fprintf(trace->output, "%22s %10.3f %s %d/%d [%d]\n",
1719 perf_evsel__name(evsel), ts,
1720 thread__comm_str(thread),
1721 sample->pid, sample->tid, sample->cpu);
1722 }
1723
1724 return printed;
1725}
1726
8a041f86
ACM		 1727static void *syscall__augmented_args(struct syscall *sc, struct perf_sample *sample, int *augmented_args_size)
1728{
1729 void *augmented_args = NULL;
1730
1731 *augmented_args_size = sample->raw_size - sc->args_size;
1732 if (*augmented_args_size > 0)
1733 augmented_args = sample->raw_data + sc->args_size;
1734
1735 return augmented_args;
1736}
1737
ba3d7dee 1738static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1739 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1740 struct perf_sample *sample)
1741{
752fde44 1742 char *msg;
ba3d7dee 1743 void *args;
752fde44 1744 size_t printed = 0;
2ae3a312 1745 struct thread *thread;
b91fc39f 1746 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
db2da3f8
ACM		 1747 int augmented_args_size = 0;
1748 void *augmented_args = NULL;
bf2575c1 1749 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1750 struct thread_trace *ttrace;
1751
1752 if (sc == NULL)
1753 return -1;
ba3d7dee 1754
8fb598e5 1755 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1756 ttrace = thread__trace(thread, trace->output);
2ae3a312 1757 if (ttrace == NULL)
b91fc39f 1758 goto out_put;
ba3d7dee 1759
591421e1
ACM		 1760 trace__fprintf_sample(trace, evsel, sample, thread);
1761
77170988 1762 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
752fde44
ACM		 1763
1764 if (ttrace->entry_str == NULL) {
e4d44e83 1765 ttrace->entry_str = malloc(trace__entry_str_size);
752fde44 1766 if (!ttrace->entry_str)
b91fc39f 1767 goto out_put;
752fde44
ACM		 1768 }
1769
5cf9c84e 1770 if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
522283fe 1771 trace__printf_interrupted_entry(trace);
db2da3f8
ACM		 1772 /*
1773 * If this is raw_syscalls.sys_enter, then it always comes with the 6 possible
1774 * arguments, even if the syscall being handled, say "openat", uses only 4 arguments
1775 * this breaks syscall__augmented_args() check for augmented args, as we calculate
1776 * syscall->args_size using each syscalls:sys_enter_NAME tracefs format file,
1777 * so when handling, say the openat syscall, we end up getting 6 args for the
1778 * raw_syscalls:sys_enter event, when we expected just 4, we end up mistakenly
1779 * thinking that the extra 2 u64 args are the augmented filename, so just check
1780 * here and avoid using augmented syscalls when the evsel is the raw_syscalls one.
1781 */
1782 if (evsel != trace->syscalls.events.sys_enter)
1783 augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
752fde44
ACM		 1784 ttrace->entry_time = sample->time;
1785 msg = ttrace->entry_str;
e4d44e83 1786 printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
752fde44 1787
e4d44e83 1788 printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
db2da3f8 1789 args, augmented_args, augmented_args_size, trace, thread);
752fde44 1790
5089f20e 1791 if (sc->is_exit) {
0a6545bd 1792 if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {
fd2b2975 1793 trace__fprintf_entry_head(trace, thread, 0, false, ttrace->entry_time, trace->output);
c008f78f 1794 fprintf(trace->output, "%-70s)\n", ttrace->entry_str);
ae9ed035 1795 }
7f4f8001 1796 } else {
752fde44 1797 ttrace->entry_pending = true;
7f4f8001
ACM		 1798 /* See trace__vfs_getname & trace__sys_exit */
1799 ttrace->filename.pending_open = false;
1800 }
ba3d7dee 1801
f3b623b8
ACM		 1802 if (trace->current != thread) {
1803 thread__put(trace->current);
1804 trace->current = thread__get(thread);
1805 }
b91fc39f
ACM		 1806 err = 0;
1807out_put:
1808 thread__put(thread);
1809 return err;
ba3d7dee
ACM		 1810}
1811
a98392bb
ACM		 1812static int trace__fprintf_sys_enter(struct trace *trace, struct perf_evsel *evsel,
1813 struct perf_sample *sample)
1814{
a98392bb
ACM		 1815 struct thread_trace *ttrace;
1816 struct thread *thread;
f3acd886
ACM		 1817 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1818 struct syscall *sc = trace__syscall_info(trace, evsel, id);
a98392bb 1819 char msg[1024];
7a983a0f
ACM		 1820 void *args, *augmented_args = NULL;
1821 int augmented_args_size;
a98392bb 1822
a98392bb
ACM		 1823 if (sc == NULL)
1824 return -1;
1825
1826 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1827 ttrace = thread__trace(thread, trace->output);
1828 /*
1829 * We need to get ttrace just to make sure it is there when syscall__scnprintf_args()
1830 * and the rest of the beautifiers accessing it via struct syscall_arg touches it.
1831 */
1832 if (ttrace == NULL)
1833 goto out_put;
1834
f3acd886 1835 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
8a041f86 1836 augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size);
7a983a0f 1837 syscall__scnprintf_args(sc, msg, sizeof(msg), args, augmented_args, augmented_args_size, trace, thread);
a98392bb
ACM		 1838 fprintf(trace->output, "%s", msg);
1839 err = 0;
1840out_put:
1841 thread__put(thread);
1842 return err;
1843}
1844
5cf9c84e
ACM		 1845static int trace__resolve_callchain(struct trace *trace, struct perf_evsel *evsel,
1846 struct perf_sample *sample,
1847 struct callchain_cursor *cursor)
202ff968
ACM		 1848{
1849 struct addr_location al;
3a9e9a47
RB		 1850 int max_stack = evsel->attr.sample_max_stack ?
1851 evsel->attr.sample_max_stack :
1852 trace->max_stack;
4291bf5c 1853 int err;
5cf9c84e 1854
4291bf5c 1855 if (machine__resolve(trace->host, &al, sample) < 0)
5cf9c84e
ACM		 1856 return -1;
1857
4291bf5c
ACM		 1858 err = thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack);
1859 addr_location__put(&al);
1860 return err;
5cf9c84e
ACM		 1861}
1862
1863static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
1864{
202ff968 1865 /* TODO: user-configurable print_opts */
e20ab86e
ACM		 1866 const unsigned int print_opts = EVSEL__PRINT_SYM |
1867 EVSEL__PRINT_DSO |
1868 EVSEL__PRINT_UNKNOWN_AS_ADDR;
202ff968 1869
d327e60c 1870 return sample__fprintf_callchain(sample, 38, print_opts, &callchain_cursor, trace->output);
202ff968
ACM		 1871}
1872
092bd3cd
HB		 1873static const char *errno_to_name(struct perf_evsel *evsel, int err)
1874{
1875 struct perf_env *env = perf_evsel__env(evsel);
1876 const char *arch_name = perf_env__arch(env);
1877
1878 return arch_syscalls__strerrno(arch_name, err);
1879}
1880
ba3d7dee 1881static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1882 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1883 struct perf_sample *sample)
1884{
2c82c3ad 1885 long ret;
60c907ab 1886 u64 duration = 0;
fd2b2975 1887 bool duration_calculated = false;
2ae3a312 1888 struct thread *thread;
5cf9c84e 1889 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0;
bf2575c1 1890 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1891 struct thread_trace *ttrace;
1892
1893 if (sc == NULL)
1894 return -1;
ba3d7dee 1895
8fb598e5 1896 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1897 ttrace = thread__trace(thread, trace->output);
2ae3a312 1898 if (ttrace == NULL)
b91fc39f 1899 goto out_put;
ba3d7dee 1900
591421e1
ACM		 1901 trace__fprintf_sample(trace, evsel, sample, thread);
1902
bf2575c1
DA		 1903 if (trace->summary)
1904 thread__update_stats(ttrace, id, sample);
1905
77170988 1906 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
ba3d7dee 1907
6a648b53 1908 if (sc->is_open && ret >= 0 && ttrace->filename.pending_open) {
7f4f8001
ACM		 1909 trace__set_fd_pathname(thread, ret, ttrace->filename.name);
1910 ttrace->filename.pending_open = false;
c522739d
ACM		 1911 ++trace->stats.vfs_getname;
1912 }
1913
ae9ed035 1914 if (ttrace->entry_time) {
60c907ab 1915 duration = sample->time - ttrace->entry_time;
ae9ed035
ACM		 1916 if (trace__filter_duration(trace, duration))
1917 goto out;
fd2b2975 1918 duration_calculated = true;
ae9ed035
ACM		 1919 } else if (trace->duration_filter)
1920 goto out;
60c907ab 1921
5cf9c84e
ACM		 1922 if (sample->callchain) {
1923 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
1924 if (callchain_ret == 0) {
1925 if (callchain_cursor.nr < trace->min_stack)
1926 goto out;
1927 callchain_ret = 1;
1928 }
1929 }
1930
0a6545bd 1931 if (trace->summary_only || (ret >= 0 && trace->failure_only))
fd2eabaf
DA		 1932 goto out;
1933
fd2b2975 1934 trace__fprintf_entry_head(trace, thread, duration, duration_calculated, ttrace->entry_time, trace->output);
752fde44
ACM		 1935
1936 if (ttrace->entry_pending) {
c24ff998 1937 fprintf(trace->output, "%-70s", ttrace->entry_str);
752fde44 1938 } else {
c24ff998
ACM		 1939 fprintf(trace->output, " ... [");
1940 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1941 fprintf(trace->output, "]: %s()", sc->name);
752fde44
ACM		 1942 }
1943
da3c9a44 1944 if (sc->fmt == NULL) {
1f63139c
ACM		 1945 if (ret < 0)
1946 goto errno_print;
da3c9a44 1947signed_print:
6f8fe61e 1948 fprintf(trace->output, ") = %ld", ret);
1f63139c
ACM		 1949 } else if (ret < 0) {
1950errno_print: {
942a91ed 1951 char bf[STRERR_BUFSIZE];
c8b5f2c9 1952 const char *emsg = str_error_r(-ret, bf, sizeof(bf)),
092bd3cd 1953 *e = errno_to_name(evsel, -ret);
ba3d7dee 1954
c24ff998 1955 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1f63139c 1956 }
da3c9a44 1957 } else if (ret == 0 && sc->fmt->timeout)
c24ff998 1958 fprintf(trace->output, ") = 0 Timeout");
84486caa
ACM		 1959 else if (ttrace->ret_scnprintf) {
1960 char bf[1024];
7ee57434
ACM		 1961 struct syscall_arg arg = {
1962 .val = ret,
1963 .thread = thread,
1964 .trace = trace,
1965 };
1966 ttrace->ret_scnprintf(bf, sizeof(bf), &arg);
84486caa
ACM		 1967 ttrace->ret_scnprintf = NULL;
1968 fprintf(trace->output, ") = %s", bf);
1969 } else if (sc->fmt->hexret)
2c82c3ad 1970 fprintf(trace->output, ") = %#lx", ret);
11c8e39f
ACM		 1971 else if (sc->fmt->errpid) {
1972 struct thread *child = machine__find_thread(trace->host, ret, ret);
1973
1974 if (child != NULL) {
1975 fprintf(trace->output, ") = %ld", ret);
1976 if (child->comm_set)
1977 fprintf(trace->output, " (%s)", thread__comm_str(child));
1978 thread__put(child);
1979 }
1980 } else
da3c9a44 1981 goto signed_print;
ba3d7dee 1982
c24ff998 1983 fputc('\n', trace->output);
566a0885 1984
5067a8cd
ACM		 1985 /*
1986 * We only consider an 'event' for the sake of --max-events a non-filtered
1987 * sys_enter + sys_exit and other tracepoint events.
1988 */
1989 if (++trace->nr_events_printed == trace->max_events && trace->max_events != ULONG_MAX)
1990 interrupted = true;
1991
5cf9c84e
ACM		 1992 if (callchain_ret > 0)
1993 trace__fprintf_callchain(trace, sample);
1994 else if (callchain_ret < 0)
1995 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
ae9ed035 1996out:
752fde44 1997 ttrace->entry_pending = false;
b91fc39f
ACM		 1998 err = 0;
1999out_put:
2000 thread__put(thread);
2001 return err;
ba3d7dee
ACM		 2002}
2003
c522739d 2004static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 2005 union perf_event *event __maybe_unused,
c522739d
ACM		 2006 struct perf_sample *sample)
2007{
f994592d
ACM		 2008 struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2009 struct thread_trace *ttrace;
2010 size_t filename_len, entry_str_len, to_move;
2011 ssize_t remaining_space;
2012 char *pos;
7f4f8001 2013 const char *filename = perf_evsel__rawptr(evsel, sample, "pathname");
f994592d
ACM		 2014
2015 if (!thread)
2016 goto out;
2017
2018 ttrace = thread__priv(thread);
2019 if (!ttrace)
ef65e96e 2020 goto out_put;
f994592d 2021
7f4f8001 2022 filename_len = strlen(filename);
39f0e7a8 2023 if (filename_len == 0)
ef65e96e 2024 goto out_put;
7f4f8001
ACM		 2025
2026 if (ttrace->filename.namelen < filename_len) {
2027 char *f = realloc(ttrace->filename.name, filename_len + 1);
2028
2029 if (f == NULL)
ef65e96e 2030 goto out_put;
7f4f8001
ACM		 2031
2032 ttrace->filename.namelen = filename_len;
2033 ttrace->filename.name = f;
2034 }
2035
2036 strcpy(ttrace->filename.name, filename);
2037 ttrace->filename.pending_open = true;
2038
f994592d 2039 if (!ttrace->filename.ptr)
ef65e96e 2040 goto out_put;
f994592d
ACM		 2041
2042 entry_str_len = strlen(ttrace->entry_str);
2043 remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
2044 if (remaining_space <= 0)
ef65e96e 2045 goto out_put;
f994592d 2046
f994592d
ACM		 2047 if (filename_len > (size_t)remaining_space) {
2048 filename += filename_len - remaining_space;
2049 filename_len = remaining_space;
2050 }
2051
2052 to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
2053 pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
2054 memmove(pos + filename_len, pos, to_move);
2055 memcpy(pos, filename, filename_len);
2056
2057 ttrace->filename.ptr = 0;
2058 ttrace->filename.entry_str_pos = 0;
ef65e96e
ACM		 2059out_put:
2060 thread__put(thread);
f994592d 2061out:
c522739d
ACM		 2062 return 0;
2063}
2064
1302d88e 2065static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 2066 union perf_event *event __maybe_unused,
1302d88e
ACM		 2067 struct perf_sample *sample)
2068{
2069 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
2070 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
8fb598e5 2071 struct thread *thread = machine__findnew_thread(trace->host,
314add6b
AH		 2072 sample->pid,
2073 sample->tid);
c24ff998 2074 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1302d88e
ACM		 2075
2076 if (ttrace == NULL)
2077 goto out_dump;
2078
2079 ttrace->runtime_ms += runtime_ms;
2080 trace->runtime_ms += runtime_ms;
ef65e96e 2081out_put:
b91fc39f 2082 thread__put(thread);
1302d88e
ACM		 2083 return 0;
2084
2085out_dump:
c24ff998 2086 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1302d88e
ACM		 2087 evsel->name,
2088 perf_evsel__strval(evsel, sample, "comm"),
2089 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
2090 runtime,
2091 perf_evsel__intval(evsel, sample, "vruntime"));
ef65e96e 2092 goto out_put;
1302d88e
ACM		 2093}
2094
923d0c9a
ACM		 2095static int bpf_output__printer(enum binary_printer_ops op,
2096 unsigned int val, void *extra __maybe_unused, FILE *fp)
1d6c9407 2097{
1d6c9407
WN		 2098 unsigned char ch = (unsigned char)val;
2099
2100 switch (op) {
2101 case BINARY_PRINT_CHAR_DATA:
923d0c9a 2102 return fprintf(fp, "%c", isprint(ch) ? ch : '.');
1d6c9407
WN		 2103 case BINARY_PRINT_DATA_BEGIN:
2104 case BINARY_PRINT_LINE_BEGIN:
2105 case BINARY_PRINT_ADDR:
2106 case BINARY_PRINT_NUM_DATA:
2107 case BINARY_PRINT_NUM_PAD:
2108 case BINARY_PRINT_SEP:
2109 case BINARY_PRINT_CHAR_PAD:
2110 case BINARY_PRINT_LINE_END:
2111 case BINARY_PRINT_DATA_END:
2112 default:
2113 break;
2114 }
923d0c9a
ACM		 2115
2116 return 0;
1d6c9407
WN		 2117}
2118
2119static void bpf_output__fprintf(struct trace *trace,
2120 struct perf_sample *sample)
2121{
923d0c9a
ACM		 2122 binary__fprintf(sample->raw_data, sample->raw_size, 8,
2123 bpf_output__printer, NULL, trace->output);
5067a8cd 2124 ++trace->nr_events_printed;
1d6c9407
WN		 2125}
2126
14a052df
ACM		 2127static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
2128 union perf_event *event __maybe_unused,
2129 struct perf_sample *sample)
2130{
a9c5e6c1 2131 struct thread *thread;
7ad35615 2132 int callchain_ret = 0;
a9c5e6c1
ACM		 2133 /*
2134 * Check if we called perf_evsel__disable(evsel) due to, for instance,
2135 * this event's max_events having been hit and this is an entry coming
2136 * from the ring buffer that we should discard, since the max events
2137 * have already been considered/printed.
2138 */
2139 if (evsel->disabled)
2140 return 0;
2141
2142 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
7ad35615
ACM		 2143
2144 if (sample->callchain) {
2145 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
2146 if (callchain_ret == 0) {
2147 if (callchain_cursor.nr < trace->min_stack)
2148 goto out;
2149 callchain_ret = 1;
2150 }
2151 }
2152
522283fe 2153 trace__printf_interrupted_entry(trace);
14a052df 2154 trace__fprintf_tstamp(trace, sample->time, trace->output);
0808921a
ACM		 2155
2156 if (trace->trace_syscalls)
2157 fprintf(trace->output, "( ): ");
2158
c4191e55
ACM		 2159 if (thread)
2160 trace__fprintf_comm_tid(trace, thread, trace->output);
2161
1cdf618f
ACM		 2162 if (evsel == trace->syscalls.events.augmented) {
2163 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
2164 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2165
2166 if (sc) {
c4191e55
ACM		 2167 fprintf(trace->output, "%s(", sc->name);
2168 trace__fprintf_sys_enter(trace, evsel, sample);
2169 fputc(')', trace->output);
2170 goto newline;
1cdf618f
ACM		 2171 }
2172
2173 /*
2174 * XXX: Not having the associated syscall info or not finding/adding
2175 * the thread should never happen, but if it does...
2176 * fall thru and print it as a bpf_output event.
2177 */
2178 }
2179
0808921a 2180 fprintf(trace->output, "%s:", evsel->name);
14a052df 2181
1d6c9407 2182 if (perf_evsel__is_bpf_output(evsel)) {
1cdf618f 2183 bpf_output__fprintf(trace, sample);
1d6c9407 2184 } else if (evsel->tp_format) {
a98392bb
ACM		 2185 if (strncmp(evsel->tp_format->name, "sys_enter_", 10) ||
2186 trace__fprintf_sys_enter(trace, evsel, sample)) {
2187 event_format__fprintf(evsel->tp_format, sample->cpu,
2188 sample->raw_data, sample->raw_size,
2189 trace->output);
5067a8cd 2190 ++trace->nr_events_printed;
a9c5e6c1
ACM		 2191
2192 if (evsel->max_events != ULONG_MAX && ++evsel->nr_events_printed == evsel->max_events) {
2193 perf_evsel__disable(evsel);
2194 perf_evsel__close(evsel);
2195 }
a98392bb 2196 }
14a052df
ACM		 2197 }
2198
1cdf618f 2199newline:
51125a29 2200 fprintf(trace->output, "\n");
202ff968 2201
7ad35615
ACM		 2202 if (callchain_ret > 0)
2203 trace__fprintf_callchain(trace, sample);
2204 else if (callchain_ret < 0)
2205 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
2206out:
a937c665 2207 thread__put(thread);
14a052df
ACM		 2208 return 0;
2209}
2210
598d02c5
SF		 2211static void print_location(FILE *f, struct perf_sample *sample,
2212 struct addr_location *al,
2213 bool print_dso, bool print_sym)
2214{
2215
bb963e16 2216 if ((verbose > 0 || print_dso) && al->map)
598d02c5
SF		 2217 fprintf(f, "%s@", al->map->dso->long_name);
2218
bb963e16 2219 if ((verbose > 0 || print_sym) && al->sym)
4414a3c5 2220 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
598d02c5
SF		 2221 al->addr - al->sym->start);
2222 else if (al->map)
4414a3c5 2223 fprintf(f, "0x%" PRIx64, al->addr);
598d02c5 2224 else
4414a3c5 2225 fprintf(f, "0x%" PRIx64, sample->addr);
598d02c5
SF		 2226}
2227
2228static int trace__pgfault(struct trace *trace,
2229 struct perf_evsel *evsel,
473398a2 2230 union perf_event *event __maybe_unused,
598d02c5
SF		 2231 struct perf_sample *sample)
2232{
2233 struct thread *thread;
598d02c5
SF		 2234 struct addr_location al;
2235 char map_type = 'd';
a2ea67d7 2236 struct thread_trace *ttrace;
b91fc39f 2237 int err = -1;
1df54290 2238 int callchain_ret = 0;
598d02c5
SF		 2239
2240 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1df54290
ACM		 2241
2242 if (sample->callchain) {
2243 callchain_ret = trace__resolve_callchain(trace, evsel, sample, &callchain_cursor);
2244 if (callchain_ret == 0) {
2245 if (callchain_cursor.nr < trace->min_stack)
2246 goto out_put;
2247 callchain_ret = 1;
2248 }
2249 }
2250
a2ea67d7
SF		 2251 ttrace = thread__trace(thread, trace->output);
2252 if (ttrace == NULL)
b91fc39f 2253 goto out_put;
a2ea67d7
SF		 2254
2255 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
2256 ttrace->pfmaj++;
2257 else
2258 ttrace->pfmin++;
2259
2260 if (trace->summary_only)
b91fc39f 2261 goto out;
598d02c5 2262
4546263d 2263 thread__find_symbol(thread, sample->cpumode, sample->ip, &al);
598d02c5 2264
fd2b2975 2265 trace__fprintf_entry_head(trace, thread, 0, true, sample->time, trace->output);
598d02c5
SF		 2266
2267 fprintf(trace->output, "%sfault [",
2268 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
2269 "maj" : "min");
2270
2271 print_location(trace->output, sample, &al, false, true);
2272
2273 fprintf(trace->output, "] => ");
2274
117d3c24 2275 thread__find_symbol(thread, sample->cpumode, sample->addr, &al);
598d02c5
SF		 2276
2277 if (!al.map) {
4546263d 2278 thread__find_symbol(thread, sample->cpumode, sample->addr, &al);
598d02c5
SF		 2279
2280 if (al.map)
2281 map_type = 'x';
2282 else
2283 map_type = '?';
2284 }
2285
2286 print_location(trace->output, sample, &al, true, false);
2287
2288 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
0c3a6ef4 2289
1df54290
ACM		 2290 if (callchain_ret > 0)
2291 trace__fprintf_callchain(trace, sample);
2292 else if (callchain_ret < 0)
2293 pr_err("Problem processing %s callchain, skipping...\n", perf_evsel__name(evsel));
5067a8cd
ACM		 2294
2295 ++trace->nr_events_printed;
b91fc39f
ACM		 2296out:
2297 err = 0;
2298out_put:
2299 thread__put(thread);
2300 return err;
598d02c5
SF		 2301}
2302
e6001980 2303static void trace__set_base_time(struct trace *trace,
8a07a809 2304 struct perf_evsel *evsel,
e6001980
ACM		 2305 struct perf_sample *sample)
2306{
8a07a809
ACM		 2307 /*
2308 * BPF events were not setting PERF_SAMPLE_TIME, so be more robust
2309 * and don't use sample->time unconditionally, we may end up having
2310 * some other event in the future without PERF_SAMPLE_TIME for good
2311 * reason, i.e. we may not be interested in its timestamps, just in
2312 * it taking place, picking some piece of information when it
2313 * appears in our event stream (vfs_getname comes to mind).
2314 */
2315 if (trace->base_time == 0 && !trace->full_time &&
2316 (evsel->attr.sample_type & PERF_SAMPLE_TIME))
e6001980
ACM		 2317 trace->base_time = sample->time;
2318}
2319
6810fc91 2320static int trace__process_sample(struct perf_tool *tool,
0c82adcf 2321 union perf_event *event,
6810fc91
DA		 2322 struct perf_sample *sample,
2323 struct perf_evsel *evsel,
2324 struct machine *machine __maybe_unused)
2325{
2326 struct trace *trace = container_of(tool, struct trace, tool);
aa07df6e 2327 struct thread *thread;
6810fc91
DA		 2328 int err = 0;
2329
744a9719 2330 tracepoint_handler handler = evsel->handler;
6810fc91 2331
aa07df6e
DA		 2332 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2333 if (thread && thread__is_filtered(thread))
ef65e96e 2334 goto out;
bdc89661 2335
e6001980 2336 trace__set_base_time(trace, evsel, sample);
6810fc91 2337
3160565f
DA		 2338 if (handler) {
2339 ++trace->nr_events;
0c82adcf 2340 handler(trace, evsel, event, sample);
3160565f 2341 }
ef65e96e
ACM		 2342out:
2343 thread__put(thread);
6810fc91
DA		 2344 return err;
2345}
2346
1e28fe0a 2347static int trace__record(struct trace *trace, int argc, const char **argv)
5e2485b1
DA		 2348{
2349 unsigned int rec_argc, i, j;
2350 const char **rec_argv;
2351 const char * const record_args[] = {
2352 "record",
2353 "-R",
2354 "-m", "1024",
2355 "-c", "1",
5e2485b1
DA		 2356 };
2357
1e28fe0a
SF		 2358 const char * const sc_args[] = { "-e", };
2359 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2360 const char * const majpf_args[] = { "-e", "major-faults" };
2361 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2362 const char * const minpf_args[] = { "-e", "minor-faults" };
2363 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2364
9aca7f17 2365 /* +1 is for the event string below */
1e28fe0a
SF		 2366 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2367 majpf_args_nr + minpf_args_nr + argc;
5e2485b1
DA		 2368 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2369
2370 if (rec_argv == NULL)
2371 return -ENOMEM;
2372
1e28fe0a 2373 j = 0;
5e2485b1 2374 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1e28fe0a
SF		 2375 rec_argv[j++] = record_args[i];
2376
e281a960
SF		 2377 if (trace->trace_syscalls) {
2378 for (i = 0; i < sc_args_nr; i++)
2379 rec_argv[j++] = sc_args[i];
2380
2381 /* event string may be different for older kernels - e.g., RHEL6 */
2382 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2383 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2384 else if (is_valid_tracepoint("syscalls:sys_enter"))
2385 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2386 else {
2387 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
c896f85a 2388 free(rec_argv);
e281a960
SF		 2389 return -1;
2390 }
9aca7f17 2391 }
9aca7f17 2392
1e28fe0a
SF		 2393 if (trace->trace_pgfaults & TRACE_PFMAJ)
2394 for (i = 0; i < majpf_args_nr; i++)
2395 rec_argv[j++] = majpf_args[i];
2396
2397 if (trace->trace_pgfaults & TRACE_PFMIN)
2398 for (i = 0; i < minpf_args_nr; i++)
2399 rec_argv[j++] = minpf_args[i];
2400
2401 for (i = 0; i < (unsigned int)argc; i++)
2402 rec_argv[j++] = argv[i];
5e2485b1 2403
b0ad8ea6 2404 return cmd_record(j, rec_argv);
5e2485b1
DA		 2405}
2406
bf2575c1
DA		 2407static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2408
08c98776 2409static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
c522739d 2410{
ef503831 2411 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
8dd2a131
JO		 2412
2413 if (IS_ERR(evsel))
08c98776 2414 return false;
c522739d
ACM		 2415
2416 if (perf_evsel__field(evsel, "pathname") == NULL) {
2417 perf_evsel__delete(evsel);
08c98776 2418 return false;
c522739d
ACM		 2419 }
2420
744a9719 2421 evsel->handler = trace__vfs_getname;
c522739d 2422 perf_evlist__add(evlist, evsel);
08c98776 2423 return true;
c522739d
ACM		 2424}
2425
0ae537cb 2426static struct perf_evsel *perf_evsel__new_pgfault(u64 config)
598d02c5
SF		 2427{
2428 struct perf_evsel *evsel;
2429 struct perf_event_attr attr = {
2430 .type = PERF_TYPE_SOFTWARE,
2431 .mmap_data = 1,
598d02c5
SF		 2432 };
2433
2434 attr.config = config;
0524798c 2435 attr.sample_period = 1;
598d02c5
SF		 2436
2437 event_attr_init(&attr);
2438
2439 evsel = perf_evsel__new(&attr);
0ae537cb
ACM		 2440 if (evsel)
2441 evsel->handler = trace__pgfault;
598d02c5 2442
0ae537cb 2443 return evsel;
598d02c5
SF		 2444}
2445
ddbb1b13
ACM		 2446static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2447{
2448 const u32 type = event->header.type;
2449 struct perf_evsel *evsel;
2450
ddbb1b13
ACM		 2451 if (type != PERF_RECORD_SAMPLE) {
2452 trace__process_event(trace, trace->host, event, sample);
2453 return;
2454 }
2455
2456 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2457 if (evsel == NULL) {
2458 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2459 return;
2460 }
2461
e6001980
ACM		 2462 trace__set_base_time(trace, evsel, sample);
2463
ddbb1b13
ACM		 2464 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2465 sample->raw_data == NULL) {
2466 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2467 perf_evsel__name(evsel), sample->tid,
2468 sample->cpu, sample->raw_size);
2469 } else {
2470 tracepoint_handler handler = evsel->handler;
2471 handler(trace, evsel, event, sample);
2472 }
5067a8cd
ACM		 2473
2474 if (trace->nr_events_printed >= trace->max_events && trace->max_events != ULONG_MAX)
2475 interrupted = true;
ddbb1b13
ACM		 2476}
2477
c27366f0
ACM		 2478static int trace__add_syscall_newtp(struct trace *trace)
2479{
2480 int ret = -1;
2481 struct perf_evlist *evlist = trace->evlist;
2482 struct perf_evsel *sys_enter, *sys_exit;
2483
63f11c80 2484 sys_enter = perf_evsel__raw_syscall_newtp("sys_enter", trace__sys_enter);
c27366f0
ACM		 2485 if (sys_enter == NULL)
2486 goto out;
2487
2488 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2489 goto out_delete_sys_enter;
2490
63f11c80 2491 sys_exit = perf_evsel__raw_syscall_newtp("sys_exit", trace__sys_exit);
c27366f0
ACM		 2492 if (sys_exit == NULL)
2493 goto out_delete_sys_enter;
2494
2495 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2496 goto out_delete_sys_exit;
2497
08e26396
ACM		 2498 perf_evsel__config_callchain(sys_enter, &trace->opts, &callchain_param);
2499 perf_evsel__config_callchain(sys_exit, &trace->opts, &callchain_param);
2500
c27366f0
ACM		 2501 perf_evlist__add(evlist, sys_enter);
2502 perf_evlist__add(evlist, sys_exit);
2503
2ddd5c04 2504 if (callchain_param.enabled && !trace->kernel_syscallchains) {
44621819
ACM		 2505 /*
2506 * We're interested only in the user space callchain
2507 * leading to the syscall, allow overriding that for
2508 * debugging reasons using --kernel_syscall_callchains
2509 */
2510 sys_exit->attr.exclude_callchain_kernel = 1;
2511 }
2512
8b3ce757
ACM		 2513 trace->syscalls.events.sys_enter = sys_enter;
2514 trace->syscalls.events.sys_exit = sys_exit;
c27366f0
ACM		 2515
2516 ret = 0;
2517out:
2518 return ret;
2519
2520out_delete_sys_exit:
2521 perf_evsel__delete_priv(sys_exit);
2522out_delete_sys_enter:
2523 perf_evsel__delete_priv(sys_enter);
2524 goto out;
2525}
2526
19867b61
ACM		 2527static int trace__set_ev_qualifier_filter(struct trace *trace)
2528{
2529 int err = -1;
b15d0a4c 2530 struct perf_evsel *sys_exit;
19867b61
ACM		 2531 char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2532 trace->ev_qualifier_ids.nr,
2533 trace->ev_qualifier_ids.entries);
2534
2535 if (filter == NULL)
2536 goto out_enomem;
2537
3541c034
MP		 2538 if (!perf_evsel__append_tp_filter(trace->syscalls.events.sys_enter,
2539 filter)) {
b15d0a4c 2540 sys_exit = trace->syscalls.events.sys_exit;
3541c034 2541 err = perf_evsel__append_tp_filter(sys_exit, filter);
b15d0a4c 2542 }
19867b61
ACM		 2543
2544 free(filter);
2545out:
2546 return err;
2547out_enomem:
2548 errno = ENOMEM;
2549 goto out;
2550}
c27366f0 2551
dd1a5037
ACM		 2552static int trace__set_filter_loop_pids(struct trace *trace)
2553{
082ab9a1 2554 unsigned int nr = 1;
dd1a5037
ACM		 2555 pid_t pids[32] = {
2556 getpid(),
2557 };
082ab9a1
ACM		 2558 struct thread *thread = machine__find_thread(trace->host, pids[0], pids[0]);
2559
2560 while (thread && nr < ARRAY_SIZE(pids)) {
2561 struct thread *parent = machine__find_thread(trace->host, thread->ppid, thread->ppid);
2562
2563 if (parent == NULL)
2564 break;
2565
2566 if (!strcmp(thread__comm_str(parent), "sshd")) {
2567 pids[nr++] = parent->tid;
2568 break;
2569 }
2570 thread = parent;
2571 }
dd1a5037
ACM		 2572
2573 return perf_evlist__set_filter_pids(trace->evlist, nr, pids);
2574}
2575
f15eb531 2576static int trace__run(struct trace *trace, int argc, const char **argv)
514f1c67 2577{
14a052df 2578 struct perf_evlist *evlist = trace->evlist;
0ae537cb 2579 struct perf_evsel *evsel, *pgfault_maj = NULL, *pgfault_min = NULL;
efd5745e
ACM		 2580 int err = -1, i;
2581 unsigned long before;
f15eb531 2582 const bool forks = argc > 0;
46fb3c21 2583 bool draining = false;
514f1c67 2584
75b757ca
ACM		 2585 trace->live = true;
2586
c27366f0 2587 if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
801c67b0 2588 goto out_error_raw_syscalls;
514f1c67 2589
e281a960 2590 if (trace->trace_syscalls)
08c98776 2591 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
c522739d 2592
0ae537cb
ACM		 2593 if ((trace->trace_pgfaults & TRACE_PFMAJ)) {
2594 pgfault_maj = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MAJ);
2595 if (pgfault_maj == NULL)
2596 goto out_error_mem;
08e26396 2597 perf_evsel__config_callchain(pgfault_maj, &trace->opts, &callchain_param);
0ae537cb 2598 perf_evlist__add(evlist, pgfault_maj);
e2726d99 2599 }
598d02c5 2600
0ae537cb
ACM		 2601 if ((trace->trace_pgfaults & TRACE_PFMIN)) {
2602 pgfault_min = perf_evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MIN);
2603 if (pgfault_min == NULL)
2604 goto out_error_mem;
08e26396 2605 perf_evsel__config_callchain(pgfault_min, &trace->opts, &callchain_param);
0ae537cb
ACM		 2606 perf_evlist__add(evlist, pgfault_min);
2607 }
598d02c5 2608
1302d88e 2609 if (trace->sched &&
2cc990ba
ACM		 2610 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2611 trace__sched_stat_runtime))
2612 goto out_error_sched_stat_runtime;
1302d88e 2613
9ea42ba4
ACM		 2614 /*
2615 * If a global cgroup was set, apply it to all the events without an
2616 * explicit cgroup. I.e.:
2617 *
2618 * trace -G A -e sched:*switch
2619 *
2620 * Will set all raw_syscalls:sys_{enter,exit}, pgfault, vfs_getname, etc
2621 * _and_ sched:sched_switch to the 'A' cgroup, while:
2622 *
2623 * trace -e sched:*switch -G A
2624 *
2625 * will only set the sched:sched_switch event to the 'A' cgroup, all the
2626 * other events (raw_syscalls:sys_{enter,exit}, etc are left "without"
2627 * a cgroup (on the root cgroup, sys wide, etc).
2628 *
2629 * Multiple cgroups:
2630 *
2631 * trace -G A -e sched:*switch -G B
2632 *
2633 * the syscall ones go to the 'A' cgroup, the sched:sched_switch goes
2634 * to the 'B' cgroup.
2635 *
2636 * evlist__set_default_cgroup() grabs a reference of the passed cgroup
2637 * only for the evsels still without a cgroup, i.e. evsel->cgroup == NULL.
2638 */
2639 if (trace->cgroup)
2640 evlist__set_default_cgroup(trace->evlist, trace->cgroup);
2641
514f1c67
ACM		 2642 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2643 if (err < 0) {
c24ff998 2644 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
514f1c67
ACM		 2645 goto out_delete_evlist;
2646 }
2647
752fde44
ACM		 2648 err = trace__symbols_init(trace, evlist);
2649 if (err < 0) {
c24ff998 2650 fprintf(trace->output, "Problems initializing symbol libraries!\n");
03ad9747 2651 goto out_delete_evlist;
752fde44
ACM		 2652 }
2653
75d50117 2654 perf_evlist__config(evlist, &trace->opts, &callchain_param);
fde54b78 2655
f15eb531
NK		 2656 signal(SIGCHLD, sig_handler);
2657 signal(SIGINT, sig_handler);
2658
2659 if (forks) {
6ef73ec4 2660 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
735f7e0b 2661 argv, false, NULL);
f15eb531 2662 if (err < 0) {
c24ff998 2663 fprintf(trace->output, "Couldn't run the workload!\n");
03ad9747 2664 goto out_delete_evlist;
f15eb531
NK		 2665 }
2666 }
2667
514f1c67 2668 err = perf_evlist__open(evlist);
a8f23d8f
ACM		 2669 if (err < 0)
2670 goto out_error_open;
514f1c67 2671
ba504235
WN		 2672 err = bpf__apply_obj_config();
2673 if (err) {
2674 char errbuf[BUFSIZ];
2675
2676 bpf__strerror_apply_obj_config(err, errbuf, sizeof(errbuf));
2677 pr_err("ERROR: Apply config to BPF failed: %s\n",
2678 errbuf);
2679 goto out_error_open;
2680 }
2681
241b057c
ACM		 2682 /*
2683 * Better not use !target__has_task() here because we need to cover the
2684 * case where no threads were specified in the command line, but a
2685 * workload was, and in that case we will fill in the thread_map when
2686 * we fork the workload in perf_evlist__prepare_workload.
2687 */
f078c385
ACM		 2688 if (trace->filter_pids.nr > 0)
2689 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
e13798c7 2690 else if (thread_map__pid(evlist->threads, 0) == -1)
dd1a5037 2691 err = trace__set_filter_loop_pids(trace);
f078c385 2692
94ad89bc
ACM		 2693 if (err < 0)
2694 goto out_error_mem;
2695
19867b61
ACM		 2696 if (trace->ev_qualifier_ids.nr > 0) {
2697 err = trace__set_ev_qualifier_filter(trace);
2698 if (err < 0)
2699 goto out_errno;
19867b61 2700
2e5e5f87
ACM		 2701 pr_debug("event qualifier tracepoint filter: %s\n",
2702 trace->syscalls.events.sys_exit->filter);
2703 }
19867b61 2704
94ad89bc
ACM		 2705 err = perf_evlist__apply_filters(evlist, &evsel);
2706 if (err < 0)
2707 goto out_error_apply_filters;
241b057c 2708
f74b9d3a 2709 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages);
e09b18d4
ACM		 2710 if (err < 0)
2711 goto out_error_mmap;
514f1c67 2712
e36b7821 2713 if (!target__none(&trace->opts.target) && !trace->opts.initial_delay)
cb24d01d
ACM		 2714 perf_evlist__enable(evlist);
2715
f15eb531
NK		 2716 if (forks)
2717 perf_evlist__start_workload(evlist);
2718
e36b7821
AB		 2719 if (trace->opts.initial_delay) {
2720 usleep(trace->opts.initial_delay * 1000);
2721 perf_evlist__enable(evlist);
2722 }
2723
e13798c7 2724 trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
42052bea
ACM		 2725 evlist->threads->nr > 1 ||
2726 perf_evlist__first(evlist)->attr.inherit;
bd3dda9a
ACM		 2727
2728 /*
2729 * Now that we already used evsel->attr to ask the kernel to setup the
2730 * events, lets reuse evsel->attr.sample_max_stack as the limit in
2731 * trace__resolve_callchain(), allowing per-event max-stack settings
2732 * to override an explicitely set --max-stack global setting.
2733 */
2734 evlist__for_each_entry(evlist, evsel) {
27de9b2b 2735 if (evsel__has_callchain(evsel) &&
bd3dda9a
ACM		 2736 evsel->attr.sample_max_stack == 0)
2737 evsel->attr.sample_max_stack = trace->max_stack;
2738 }
514f1c67 2739again:
efd5745e 2740 before = trace->nr_events;
514f1c67
ACM		 2741
2742 for (i = 0; i < evlist->nr_mmaps; i++) {
2743 union perf_event *event;
d7f55c62 2744 struct perf_mmap *md;
514f1c67 2745
d7f55c62 2746 md = &evlist->mmap[i];
b9bae2c8 2747 if (perf_mmap__read_init(md) < 0)
d7f55c62
KL		 2748 continue;
2749
0019dc87 2750 while ((event = perf_mmap__read_event(md)) != NULL) {
514f1c67 2751 struct perf_sample sample;
514f1c67 2752
efd5745e 2753 ++trace->nr_events;
514f1c67 2754
514f1c67
ACM		 2755 err = perf_evlist__parse_sample(evlist, event, &sample);
2756 if (err) {
c24ff998 2757 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
8e50d384 2758 goto next_event;
514f1c67
ACM		 2759 }
2760
ddbb1b13 2761 trace__handle_event(trace, event, &sample);
8e50d384 2762next_event:
d6ace3df 2763 perf_mmap__consume(md);
20c5f10e 2764
ba209f85
ACM		 2765 if (interrupted)
2766 goto out_disable;
02ac5421
ACM		 2767
2768 if (done && !draining) {
2769 perf_evlist__disable(evlist);
2770 draining = true;
2771 }
514f1c67 2772 }
d7f55c62 2773 perf_mmap__read_done(md);
514f1c67
ACM		 2774 }
2775
efd5745e 2776 if (trace->nr_events == before) {
ba209f85 2777 int timeout = done ? 100 : -1;
f15eb531 2778
46fb3c21 2779 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
a9c5e6c1 2780 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP | POLLNVAL) == 0)
46fb3c21
ACM		 2781 draining = true;
2782
ba209f85 2783 goto again;
46fb3c21 2784 }
ba209f85
ACM		 2785 } else {
2786 goto again;
f15eb531
NK		 2787 }
2788
ba209f85 2789out_disable:
f3b623b8
ACM		 2790 thread__zput(trace->current);
2791
ba209f85 2792 perf_evlist__disable(evlist);
514f1c67 2793
c522739d
ACM		 2794 if (!err) {
2795 if (trace->summary)
2796 trace__fprintf_thread_summary(trace, trace->output);
2797
2798 if (trace->show_tool_stats) {
2799 fprintf(trace->output, "Stats:\n "
2800 " vfs_getname : %" PRIu64 "\n"
2801 " proc_getname: %" PRIu64 "\n",
2802 trace->stats.vfs_getname,
2803 trace->stats.proc_getname);
2804 }
2805 }
bf2575c1 2806
514f1c67 2807out_delete_evlist:
33974a41
AV		 2808 trace__symbols__exit(trace);
2809
514f1c67 2810 perf_evlist__delete(evlist);
9ea42ba4 2811 cgroup__put(trace->cgroup);
14a052df 2812 trace->evlist = NULL;
75b757ca 2813 trace->live = false;
514f1c67 2814 return err;
6ef068cb
ACM		 2815{
2816 char errbuf[BUFSIZ];
a8f23d8f 2817
2cc990ba 2818out_error_sched_stat_runtime:
988bdb31 2819 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2cc990ba
ACM		 2820 goto out_error;
2821
801c67b0 2822out_error_raw_syscalls:
988bdb31 2823 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
a8f23d8f
ACM		 2824 goto out_error;
2825
e09b18d4
ACM		 2826out_error_mmap:
2827 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2828 goto out_error;
2829
a8f23d8f
ACM		 2830out_error_open:
2831 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2832
2833out_error:
6ef068cb 2834 fprintf(trace->output, "%s\n", errbuf);
87f91868 2835 goto out_delete_evlist;
94ad89bc
ACM		 2836
2837out_error_apply_filters:
2838 fprintf(trace->output,
2839 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2840 evsel->filter, perf_evsel__name(evsel), errno,
c8b5f2c9 2841 str_error_r(errno, errbuf, sizeof(errbuf)));
94ad89bc 2842 goto out_delete_evlist;
514f1c67 2843}
5ed08dae
ACM		 2844out_error_mem:
2845 fprintf(trace->output, "Not enough memory to run!\n");
2846 goto out_delete_evlist;
19867b61
ACM		 2847
2848out_errno:
2849 fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2850 goto out_delete_evlist;
a8f23d8f 2851}
514f1c67 2852
6810fc91
DA		 2853static int trace__replay(struct trace *trace)
2854{
2855 const struct perf_evsel_str_handler handlers[] = {
c522739d 2856 { "probe:vfs_getname", trace__vfs_getname, },
6810fc91 2857 };
8ceb41d7 2858 struct perf_data data = {
eae8ad80
JO		 2859 .file = {
2860 .path = input_name,
2861 },
2862 .mode = PERF_DATA_MODE_READ,
2863 .force = trace->force,
f5fc1412 2864 };
6810fc91 2865 struct perf_session *session;
003824e8 2866 struct perf_evsel *evsel;
6810fc91
DA		 2867 int err = -1;
2868
2869 trace->tool.sample = trace__process_sample;
2870 trace->tool.mmap = perf_event__process_mmap;
384c671e 2871 trace->tool.mmap2 = perf_event__process_mmap2;
6810fc91
DA		 2872 trace->tool.comm = perf_event__process_comm;
2873 trace->tool.exit = perf_event__process_exit;
2874 trace->tool.fork = perf_event__process_fork;
2875 trace->tool.attr = perf_event__process_attr;
f3b3614a 2876 trace->tool.tracing_data = perf_event__process_tracing_data;
6810fc91 2877 trace->tool.build_id = perf_event__process_build_id;
f3b3614a 2878 trace->tool.namespaces = perf_event__process_namespaces;
6810fc91 2879
0a8cb85c 2880 trace->tool.ordered_events = true;
6810fc91
DA		 2881 trace->tool.ordering_requires_timestamps = true;
2882
2883 /* add tid to output */
2884 trace->multiple_threads = true;
2885
8ceb41d7 2886 session = perf_session__new(&data, false, &trace->tool);
6810fc91 2887 if (session == NULL)
52e02834 2888 return -1;
6810fc91 2889
aa07df6e
DA		 2890 if (trace->opts.target.pid)
2891 symbol_conf.pid_list_str = strdup(trace->opts.target.pid);
2892
2893 if (trace->opts.target.tid)
2894 symbol_conf.tid_list_str = strdup(trace->opts.target.tid);
2895
0a7e6d1b 2896 if (symbol__init(&session->header.env) < 0)
cb2ffae2
NK		 2897 goto out;
2898
8fb598e5
DA		 2899 trace->host = &session->machines.host;
2900
6810fc91
DA		 2901 err = perf_session__set_tracepoints_handlers(session, handlers);
2902 if (err)
2903 goto out;
2904
003824e8
NK		 2905 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2906 "raw_syscalls:sys_enter");
9aca7f17
DA		 2907 /* older kernels have syscalls tp versus raw_syscalls */
2908 if (evsel == NULL)
2909 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2910 "syscalls:sys_enter");
003824e8 2911
e281a960 2912 if (evsel &&
63f11c80 2913 (perf_evsel__init_raw_syscall_tp(evsel, trace__sys_enter) < 0 ||
e281a960 2914 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
003824e8
NK		 2915 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2916 goto out;
2917 }
2918
2919 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2920 "raw_syscalls:sys_exit");
9aca7f17
DA		 2921 if (evsel == NULL)
2922 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2923 "syscalls:sys_exit");
e281a960 2924 if (evsel &&
63f11c80 2925 (perf_evsel__init_raw_syscall_tp(evsel, trace__sys_exit) < 0 ||
e281a960 2926 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
003824e8 2927 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
6810fc91
DA		 2928 goto out;
2929 }
2930
e5cadb93 2931 evlist__for_each_entry(session->evlist, evsel) {
1e28fe0a
SF		 2932 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2933 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2934 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2935 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2936 evsel->handler = trace__pgfault;
2937 }
2938
6810fc91
DA		 2939 setup_pager();
2940
b7b61cbe 2941 err = perf_session__process_events(session);
6810fc91
DA		 2942 if (err)
2943 pr_err("Failed to process events, error %d", err);
2944
bf2575c1
DA		 2945 else if (trace->summary)
2946 trace__fprintf_thread_summary(trace, trace->output);
2947
6810fc91
DA		 2948out:
2949 perf_session__delete(session);
2950
2951 return err;
2952}
2953
1302d88e
ACM		 2954static size_t trace__fprintf_threads_header(FILE *fp)
2955{
2956 size_t printed;
2957
99ff7150 2958 printed = fprintf(fp, "\n Summary of events:\n\n");
bf2575c1
DA		 2959
2960 return printed;
2961}
2962
b535d523
ACM		 2963DEFINE_RESORT_RB(syscall_stats, a->msecs > b->msecs,
2964 struct stats *stats;
2965 double msecs;
2966 int syscall;
2967)
2968{
2969 struct int_node *source = rb_entry(nd, struct int_node, rb_node);
2970 struct stats *stats = source->priv;
2971
2972 entry->syscall = source->i;
2973 entry->stats = stats;
2974 entry->msecs = stats ? (u64)stats->n * (avg_stats(stats) / NSEC_PER_MSEC) : 0;
2975}
2976
bf2575c1
DA		 2977static size_t thread__dump_stats(struct thread_trace *ttrace,
2978 struct trace *trace, FILE *fp)
2979{
bf2575c1
DA		 2980 size_t printed = 0;
2981 struct syscall *sc;
b535d523
ACM		 2982 struct rb_node *nd;
2983 DECLARE_RESORT_RB_INTLIST(syscall_stats, ttrace->syscall_stats);
bf2575c1 2984
b535d523 2985 if (syscall_stats == NULL)
bf2575c1
DA		 2986 return 0;
2987
2988 printed += fprintf(fp, "\n");
2989
834fd46d
MW		 2990 printed += fprintf(fp, " syscall calls total min avg max stddev\n");
2991 printed += fprintf(fp, " (msec) (msec) (msec) (msec) (%%)\n");
2992 printed += fprintf(fp, " --------------- -------- --------- --------- --------- --------- ------\n");
99ff7150 2993
98a91837 2994 resort_rb__for_each_entry(nd, syscall_stats) {
b535d523 2995 struct stats *stats = syscall_stats_entry->stats;
bf2575c1
DA		 2996 if (stats) {
2997 double min = (double)(stats->min) / NSEC_PER_MSEC;
2998 double max = (double)(stats->max) / NSEC_PER_MSEC;
2999 double avg = avg_stats(stats);
3000 double pct;
3001 u64 n = (u64) stats->n;
3002
3003 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
3004 avg /= NSEC_PER_MSEC;
3005
b535d523 3006 sc = &trace->syscalls.table[syscall_stats_entry->syscall];
99ff7150 3007 printed += fprintf(fp, " %-15s", sc->name);
834fd46d 3008 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
b535d523 3009 n, syscall_stats_entry->msecs, min, avg);
27a778b5 3010 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
bf2575c1 3011 }
bf2575c1
DA		 3012 }
3013
b535d523 3014 resort_rb__delete(syscall_stats);
bf2575c1 3015 printed += fprintf(fp, "\n\n");
1302d88e
ACM		 3016
3017 return printed;
3018}
3019
96c14451 3020static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
896cbb56 3021{
96c14451 3022 size_t printed = 0;
89dceb22 3023 struct thread_trace *ttrace = thread__priv(thread);
896cbb56
DA		 3024 double ratio;
3025
3026 if (ttrace == NULL)
3027 return 0;
3028
3029 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
3030
15e65c69 3031 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
99ff7150 3032 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
15e65c69 3033 printed += fprintf(fp, "%.1f%%", ratio);
a2ea67d7
SF		 3034 if (ttrace->pfmaj)
3035 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
3036 if (ttrace->pfmin)
3037 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
03548ebf
ACM		 3038 if (trace->sched)
3039 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
3040 else if (fputc('\n', fp) != EOF)
3041 ++printed;
3042
bf2575c1 3043 printed += thread__dump_stats(ttrace, trace, fp);
896cbb56 3044
96c14451
ACM		 3045 return printed;
3046}
896cbb56 3047
96c14451
ACM		 3048static unsigned long thread__nr_events(struct thread_trace *ttrace)
3049{
3050 return ttrace ? ttrace->nr_events : 0;
3051}
3052
3053DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)),
3054 struct thread *thread;
3055)
3056{
3057 entry->thread = rb_entry(nd, struct thread, rb_node);
896cbb56
DA		 3058}
3059
1302d88e
ACM		 3060static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
3061{
96c14451
ACM		 3062 size_t printed = trace__fprintf_threads_header(fp);
3063 struct rb_node *nd;
91e467bc 3064 int i;
1302d88e 3065
91e467bc
KL		 3066 for (i = 0; i < THREADS__TABLE_SIZE; i++) {
3067 DECLARE_RESORT_RB_MACHINE_THREADS(threads, trace->host, i);
96c14451 3068
91e467bc
KL		 3069 if (threads == NULL) {
3070 fprintf(fp, "%s", "Error sorting output by nr_events!\n");
3071 return 0;
3072 }
896cbb56 3073
91e467bc
KL		 3074 resort_rb__for_each_entry(nd, threads)
3075 printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
96c14451 3076
91e467bc
KL		 3077 resort_rb__delete(threads);
3078 }
96c14451 3079 return printed;
1302d88e
ACM		 3080}
3081
ae9ed035
ACM		 3082static int trace__set_duration(const struct option *opt, const char *str,
3083 int unset __maybe_unused)
3084{
3085 struct trace *trace = opt->value;
3086
3087 trace->duration_filter = atof(str);
3088 return 0;
3089}
3090
f078c385
ACM		 3091static int trace__set_filter_pids(const struct option *opt, const char *str,
3092 int unset __maybe_unused)
3093{
3094 int ret = -1;
3095 size_t i;
3096 struct trace *trace = opt->value;
3097 /*
3098 * FIXME: introduce a intarray class, plain parse csv and create a
3099 * { int nr, int entries[] } struct...
3100 */
3101 struct intlist *list = intlist__new(str);
3102
3103 if (list == NULL)
3104 return -1;
3105
3106 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
3107 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
3108
3109 if (trace->filter_pids.entries == NULL)
3110 goto out;
3111
3112 trace->filter_pids.entries[0] = getpid();
3113
3114 for (i = 1; i < trace->filter_pids.nr; ++i)
3115 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
3116
3117 intlist__delete(list);
3118 ret = 0;
3119out:
3120 return ret;
3121}
3122
c24ff998
ACM		 3123static int trace__open_output(struct trace *trace, const char *filename)
3124{
3125 struct stat st;
3126
3127 if (!stat(filename, &st) && st.st_size) {
3128 char oldname[PATH_MAX];
3129
3130 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
3131 unlink(oldname);
3132 rename(filename, oldname);
3133 }
3134
3135 trace->output = fopen(filename, "w");
3136
3137 return trace->output == NULL ? -errno : 0;
3138}
3139
598d02c5
SF		 3140static int parse_pagefaults(const struct option *opt, const char *str,
3141 int unset __maybe_unused)
3142{
3143 int *trace_pgfaults = opt->value;
3144
3145 if (strcmp(str, "all") == 0)
3146 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
3147 else if (strcmp(str, "maj") == 0)
3148 *trace_pgfaults |= TRACE_PFMAJ;
3149 else if (strcmp(str, "min") == 0)
3150 *trace_pgfaults |= TRACE_PFMIN;
3151 else
3152 return -1;
3153
3154 return 0;
3155}
3156
14a052df
ACM		 3157static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
3158{
3159 struct perf_evsel *evsel;
3160
e5cadb93 3161 evlist__for_each_entry(evlist, evsel)
14a052df
ACM		 3162 evsel->handler = handler;
3163}
3164
d32855fa
ACM		 3165static int evlist__set_syscall_tp_fields(struct perf_evlist *evlist)
3166{
3167 struct perf_evsel *evsel;
3168
3169 evlist__for_each_entry(evlist, evsel) {
3170 if (evsel->priv || !evsel->tp_format)
3171 continue;
3172
3173 if (strcmp(evsel->tp_format->system, "syscalls"))
3174 continue;
3175
3176 if (perf_evsel__init_syscall_tp(evsel))
3177 return -1;
3178
3179 if (!strncmp(evsel->tp_format->name, "sys_enter_", 10)) {
3180 struct syscall_tp *sc = evsel->priv;
3181
3182 if (__tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64)))
3183 return -1;
3184 } else if (!strncmp(evsel->tp_format->name, "sys_exit_", 9)) {
3185 struct syscall_tp *sc = evsel->priv;
3186
3187 if (__tp_field__init_uint(&sc->ret, sizeof(u64), sc->id.offset + sizeof(u64), evsel->needs_swap))
3188 return -1;
3189 }
3190 }
3191
3192 return 0;
3193}
3194
017037ff
ACM		 3195/*
3196 * XXX: Hackish, just splitting the combined -e+--event (syscalls
3197 * (raw_syscalls:{sys_{enter,exit}} + events (tracepoints, HW, SW, etc) to use
3198 * existing facilities unchanged (trace->ev_qualifier + parse_options()).
3199 *
3200 * It'd be better to introduce a parse_options() variant that would return a
3201 * list with the terms it didn't match to an event...
3202 */
3203static int trace__parse_events_option(const struct option *opt, const char *str,
3204 int unset __maybe_unused)
3205{
3206 struct trace *trace = (struct trace *)opt->value;
3207 const char *s = str;
3208 char *sep = NULL, *lists[2] = { NULL, NULL, };
27702bcf 3209 int len = strlen(str) + 1, err = -1, list, idx;
017037ff
ACM		 3210 char *strace_groups_dir = system_path(STRACE_GROUPS_DIR);
3211 char group_name[PATH_MAX];
f932184e 3212 struct syscall_fmt *fmt;
017037ff
ACM		 3213
3214 if (strace_groups_dir == NULL)
3215 return -1;
3216
3217 if (*s == '!') {
3218 ++s;
3219 trace->not_ev_qualifier = true;
3220 }
3221
3222 while (1) {
3223 if ((sep = strchr(s, ',')) != NULL)
3224 *sep = '\0';
3225
3226 list = 0;
27702bcf
ACM		 3227 if (syscalltbl__id(trace->sctbl, s) >= 0 ||
3228 syscalltbl__strglobmatch_first(trace->sctbl, s, &idx) >= 0) {
017037ff 3229 list = 1;
f932184e
ACM		 3230 goto do_concat;
3231 }
3232
3233 fmt = syscall_fmt__find_by_alias(s);
3234 if (fmt != NULL) {
3235 list = 1;
3236 s = fmt->name;
017037ff
ACM		 3237 } else {
3238 path__join(group_name, sizeof(group_name), strace_groups_dir, s);
3239 if (access(group_name, R_OK) == 0)
3240 list = 1;
3241 }
f932184e 3242do_concat:
017037ff
ACM		 3243 if (lists[list]) {
3244 sprintf(lists[list] + strlen(lists[list]), ",%s", s);
3245 } else {
3246 lists[list] = malloc(len);
3247 if (lists[list] == NULL)
3248 goto out;
3249 strcpy(lists[list], s);
3250 }
3251
3252 if (!sep)
3253 break;
3254
3255 *sep = ',';
3256 s = sep + 1;
3257 }
3258
3259 if (lists[1] != NULL) {
3260 struct strlist_config slist_config = {
3261 .dirname = strace_groups_dir,
3262 };
3263
3264 trace->ev_qualifier = strlist__new(lists[1], &slist_config);
3265 if (trace->ev_qualifier == NULL) {
3266 fputs("Not enough memory to parse event qualifier", trace->output);
3267 goto out;
3268 }
3269
3270 if (trace__validate_ev_qualifier(trace))
3271 goto out;
b912885a 3272 trace->trace_syscalls = true;
017037ff
ACM		 3273 }
3274
3275 err = 0;
3276
3277 if (lists[0]) {
3278 struct option o = OPT_CALLBACK('e', "event", &trace->evlist, "event",
3279 "event selector. use 'perf list' to list available events",
3280 parse_events_option);
3281 err = parse_events_option(&o, lists[0], 0);
3282 }
3283out:
3284 if (sep)
3285 *sep = ',';
3286
3287 return err;
3288}
3289
9ea42ba4
ACM		 3290static int trace__parse_cgroups(const struct option *opt, const char *str, int unset)
3291{
3292 struct trace *trace = opt->value;
3293
3294 if (!list_empty(&trace->evlist->entries))
3295 return parse_cgroups(opt, str, unset);
3296
3297 trace->cgroup = evlist__findnew_cgroup(trace->evlist, str);
3298
3299 return 0;
3300}
3301
b0ad8ea6 3302int cmd_trace(int argc, const char **argv)
514f1c67 3303{
6fdd9cb7 3304 const char *trace_usage[] = {
f15eb531
NK		 3305 "perf trace [<options>] [<command>]",
3306 "perf trace [<options>] -- <command> [<options>]",
5e2485b1
DA		 3307 "perf trace record [<options>] [<command>]",
3308 "perf trace record [<options>] -- <command> [<options>]",
514f1c67
ACM		 3309 NULL
3310 };
3311 struct trace trace = {
514f1c67
ACM		 3312 .syscalls = {
3313 . max = -1,
3314 },
3315 .opts = {
3316 .target = {
3317 .uid = UINT_MAX,
3318 .uses_mmap = true,
3319 },
3320 .user_freq = UINT_MAX,
3321 .user_interval = ULLONG_MAX,
509051ea 3322 .no_buffering = true,
38d5447d 3323 .mmap_pages = UINT_MAX,
9d9cad76 3324 .proc_map_timeout = 500,
514f1c67 3325 },
007d66a0 3326 .output = stderr,
50c95cbd 3327 .show_comm = true,
b912885a 3328 .trace_syscalls = false,
44621819 3329 .kernel_syscallchains = false,
05614993 3330 .max_stack = UINT_MAX,
5067a8cd 3331 .max_events = ULONG_MAX,
514f1c67 3332 };
c24ff998 3333 const char *output_name = NULL;
514f1c67 3334 const struct option trace_options[] = {
017037ff
ACM		 3335 OPT_CALLBACK('e', "event", &trace, "event",
3336 "event/syscall selector. use 'perf list' to list available events",
3337 trace__parse_events_option),
50c95cbd
ACM		 3338 OPT_BOOLEAN(0, "comm", &trace.show_comm,
3339 "show the thread COMM next to its id"),
c522739d 3340 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
017037ff
ACM		 3341 OPT_CALLBACK(0, "expr", &trace, "expr", "list of syscalls/events to trace",
3342 trace__parse_events_option),
c24ff998 3343 OPT_STRING('o', "output", &output_name, "file", "output file name"),
6810fc91 3344 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
514f1c67
ACM		 3345 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
3346 "trace events on existing process id"),
ac9be8ee 3347 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
514f1c67 3348 "trace events on existing thread id"),
fa0e4ffe
ACM		 3349 OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
3350 "pids to filter (by the kernel)", trace__set_filter_pids),
ac9be8ee 3351 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
514f1c67 3352 "system-wide collection from all CPUs"),
ac9be8ee 3353 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
514f1c67 3354 "list of cpus to monitor"),
6810fc91 3355 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
514f1c67 3356 "child tasks do not inherit counters"),
994a1f78
JO		 3357 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
3358 "number of mmap data pages",
3359 perf_evlist__parse_mmap_pages),
ac9be8ee 3360 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
514f1c67 3361 "user to profile"),
ae9ed035
ACM		 3362 OPT_CALLBACK(0, "duration", &trace, "float",
3363 "show only events with duration > N.M ms",
3364 trace__set_duration),
1302d88e 3365 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
7c304ee0 3366 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
4bb09192
DA		 3367 OPT_BOOLEAN('T', "time", &trace.full_time,
3368 "Show full timestamp, not time relative to first start"),
0a6545bd
ACM		 3369 OPT_BOOLEAN(0, "failure", &trace.failure_only,
3370 "Show only syscalls that failed"),
fd2eabaf
DA		 3371 OPT_BOOLEAN('s', "summary", &trace.summary_only,
3372 "Show only syscall summary with statistics"),
3373 OPT_BOOLEAN('S', "with-summary", &trace.summary,
3374 "Show all syscalls and summary with statistics"),
598d02c5
SF		 3375 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
3376 "Trace pagefaults", parse_pagefaults, "maj"),
e281a960 3377 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
e366a6d8 3378 OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
566a0885
MW		 3379 OPT_CALLBACK(0, "call-graph", &trace.opts,
3380 "record_mode[,record_size]", record_callchain_help,
3381 &record_parse_callchain_opt),
44621819
ACM		 3382 OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
3383 "Show the kernel callchains on the syscall exit path"),
5067a8cd
ACM		 3384 OPT_ULONG(0, "max-events", &trace.max_events,
3385 "Set the maximum number of events to print, exit after that is reached. "),
5cf9c84e
ACM		 3386 OPT_UINTEGER(0, "min-stack", &trace.min_stack,
3387 "Set the minimum stack depth when parsing the callchain, "
3388 "anything below the specified depth will be ignored."),
c6d4a494
ACM		 3389 OPT_UINTEGER(0, "max-stack", &trace.max_stack,
3390 "Set the maximum stack depth when parsing the callchain, "
3391 "anything beyond the specified depth will be ignored. "
4cb93446 3392 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
591421e1
ACM		 3393 OPT_BOOLEAN(0, "print-sample", &trace.print_sample,
3394 "print the PERF_RECORD_SAMPLE PERF_SAMPLE_ info, for debugging"),
9d9cad76
KL		 3395 OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
3396 "per thread proc mmap processing timeout in ms"),
9ea42ba4
ACM		 3397 OPT_CALLBACK('G', "cgroup", &trace, "name", "monitor event in cgroup name only",
3398 trace__parse_cgroups),
e36b7821
AB		 3399 OPT_UINTEGER('D', "delay", &trace.opts.initial_delay,
3400 "ms to wait before starting measurement after program "
3401 "start"),
514f1c67
ACM		 3402 OPT_END()
3403 };
ccd62a89 3404 bool __maybe_unused max_stack_user_set = true;
f3e459d1 3405 bool mmap_pages_user_set = true;
78e890ea 3406 struct perf_evsel *evsel;
6fdd9cb7 3407 const char * const trace_subcommands[] = { "record", NULL };
78e890ea 3408 int err = -1;
32caf0d1 3409 char bf[BUFSIZ];
514f1c67 3410
4d08cb80
ACM		 3411 signal(SIGSEGV, sighandler_dump_stack);
3412 signal(SIGFPE, sighandler_dump_stack);
3413
14a052df 3414 trace.evlist = perf_evlist__new();
fd0db102 3415 trace.sctbl = syscalltbl__new();
14a052df 3416
fd0db102 3417 if (trace.evlist == NULL || trace.sctbl == NULL) {
14a052df 3418 pr_err("Not enough memory to run!\n");
ff8f695c 3419 err = -ENOMEM;
14a052df
ACM		 3420 goto out;
3421 }
3422
6fdd9cb7
YS		 3423 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
3424 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
fd2eabaf 3425
9ea42ba4
ACM		 3426 if ((nr_cgroups || trace.cgroup) && !trace.opts.target.system_wide) {
3427 usage_with_options_msg(trace_usage, trace_options,
3428 "cgroup monitoring only available in system-wide mode");
3429 }
3430
78e890ea
ACM		 3431 evsel = bpf__setup_output_event(trace.evlist, "__augmented_syscalls__");
3432 if (IS_ERR(evsel)) {
3433 bpf__strerror_setup_output_event(trace.evlist, PTR_ERR(evsel), bf, sizeof(bf));
e0b6d2ef
ACM		 3434 pr_err("ERROR: Setup trace syscalls enter failed: %s\n", bf);
3435 goto out;
3436 }
3437
b1a9e253 3438 if (evsel)
d3d1c4bd 3439 trace.syscalls.events.augmented = evsel;
d3d1c4bd 3440
d7888573
WN		 3441 err = bpf__setup_stdout(trace.evlist);
3442 if (err) {
3443 bpf__strerror_setup_stdout(trace.evlist, err, bf, sizeof(bf));
3444 pr_err("ERROR: Setup BPF stdout failed: %s\n", bf);
3445 goto out;
3446 }
3447
59247e33
ACM		 3448 err = -1;
3449
598d02c5
SF		 3450 if (trace.trace_pgfaults) {
3451 trace.opts.sample_address = true;
3452 trace.opts.sample_time = true;
3453 }
3454
f3e459d1
ACM		 3455 if (trace.opts.mmap_pages == UINT_MAX)
3456 mmap_pages_user_set = false;
3457
05614993 3458 if (trace.max_stack == UINT_MAX) {
029c75e5 3459 trace.max_stack = input_name ? PERF_MAX_STACK_DEPTH : sysctl__max_stack();
05614993
ACM		 3460 max_stack_user_set = false;
3461 }
3462
3463#ifdef HAVE_DWARF_UNWIND_SUPPORT
75d50117 3464 if ((trace.min_stack || max_stack_user_set) && !callchain_param.enabled) {
05614993 3465 record_opts__parse_callchain(&trace.opts, &callchain_param, "dwarf", false);
75d50117 3466 }
05614993
ACM		 3467#endif
3468
2ddd5c04 3469 if (callchain_param.enabled) {
f3e459d1
ACM		 3470 if (!mmap_pages_user_set && geteuid() == 0)
3471 trace.opts.mmap_pages = perf_event_mlock_kb_in_pages() * 4;
3472
566a0885 3473 symbol_conf.use_callchain = true;
f3e459d1 3474 }
566a0885 3475
d32855fa 3476 if (trace.evlist->nr_entries > 0) {
14a052df 3477 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
d32855fa
ACM		 3478 if (evlist__set_syscall_tp_fields(trace.evlist)) {
3479 perror("failed to set syscalls:* tracepoint fields");
3480 goto out;
3481 }
3482 }
14a052df 3483
b1a9e253
ACM		 3484 /*
3485 * If we are augmenting syscalls, then combine what we put in the
3486 * __augmented_syscalls__ BPF map with what is in the
3487 * syscalls:sys_exit_FOO tracepoints, i.e. just like we do without BPF,
3488 * combining raw_syscalls:sys_enter with raw_syscalls:sys_exit.
3489 *
3490 * We'll switch to look at two BPF maps, one for sys_enter and the
3491 * other for sys_exit when we start augmenting the sys_exit paths with
3492 * buffers that are being copied from kernel to userspace, think 'read'
3493 * syscall.
3494 */
3495 if (trace.syscalls.events.augmented) {
3496 evsel = trace.syscalls.events.augmented;
3497
3498 if (perf_evsel__init_augmented_syscall_tp(evsel) ||
3499 perf_evsel__init_augmented_syscall_tp_args(evsel))
3500 goto out;
3501 evsel->handler = trace__sys_enter;
3502
3503 evlist__for_each_entry(trace.evlist, evsel) {
3504 if (strstarts(perf_evsel__name(evsel), "syscalls:sys_exit_")) {
3505 perf_evsel__init_augmented_syscall_tp(evsel);
3506 perf_evsel__init_augmented_syscall_tp_ret(evsel);
3507 evsel->handler = trace__sys_exit;
3508 }
3509 }
3510 }
3511
1e28fe0a
SF		 3512 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
3513 return trace__record(&trace, argc-1, &argv[1]);
3514
3515 /* summary_only implies summary option, but don't overwrite summary if set */
3516 if (trace.summary_only)
3517 trace.summary = trace.summary_only;
3518
726f3234
ACM		 3519 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
3520 trace.evlist->nr_entries == 0 /* Was --events used? */) {
b912885a 3521 trace.trace_syscalls = true;
59247e33
ACM		 3522 }
3523
c24ff998
ACM		 3524 if (output_name != NULL) {
3525 err = trace__open_output(&trace, output_name);
3526 if (err < 0) {
3527 perror("failed to create output file");
3528 goto out;
3529 }
3530 }
3531
602ad878 3532 err = target__validate(&trace.opts.target);
32caf0d1 3533 if (err) {
602ad878 3534 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 3535 fprintf(trace.output, "%s", bf);
3536 goto out_close;
32caf0d1
NK		 3537 }
3538
602ad878 3539 err = target__parse_uid(&trace.opts.target);
514f1c67 3540 if (err) {
602ad878 3541 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 3542 fprintf(trace.output, "%s", bf);
3543 goto out_close;
514f1c67
ACM		 3544 }
3545
602ad878 3546 if (!argc && target__none(&trace.opts.target))
ee76120e
NK		 3547 trace.opts.target.system_wide = true;
3548
6810fc91
DA		 3549 if (input_name)
3550 err = trace__replay(&trace);
3551 else
3552 err = trace__run(&trace, argc, argv);
1302d88e 3553
c24ff998
ACM		 3554out_close:
3555 if (output_name != NULL)
3556 fclose(trace.output);
3557out:
1302d88e 3558 return err;
514f1c67 3559}
Linux 6.x block layer and io_uring tree(s)