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