projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf probe: Remove all probes matches given pattern at once
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / tools / perf / builtin-trace.c
CommitLineData
4e319027 1#include <traceevent/event-parse.h>
514f1c67 2#include "builtin.h"
752fde44 3#include "util/color.h"
7c304ee0 4#include "util/debug.h"
514f1c67 5#include "util/evlist.h"
752fde44 6#include "util/machine.h"
6810fc91 7#include "util/session.h"
752fde44 8#include "util/thread.h"
514f1c67 9#include "util/parse-options.h"
2ae3a312 10#include "util/strlist.h"
bdc89661 11#include "util/intlist.h"
514f1c67 12#include "util/thread_map.h"
bf2575c1 13#include "util/stat.h"
97978b3e 14#include "trace-event.h"
9aca7f17 15#include "util/parse-events.h"
514f1c67
ACM		 16
17#include <libaudit.h>
18#include <stdlib.h>
49af9e93 19#include <sys/eventfd.h>
ae685380 20#include <sys/mman.h>
f9da0b0c 21#include <linux/futex.h>
514f1c67 22
456857bd
IM		 23/* For older distros: */
24#ifndef MAP_STACK
25# define MAP_STACK 0x20000
26#endif
27
28#ifndef MADV_HWPOISON
29# define MADV_HWPOISON 100
30#endif
31
32#ifndef MADV_MERGEABLE
33# define MADV_MERGEABLE 12
34#endif
35
36#ifndef MADV_UNMERGEABLE
37# define MADV_UNMERGEABLE 13
38#endif
39
79d26a6a
BH		 40#ifndef EFD_SEMAPHORE
41# define EFD_SEMAPHORE 1
42#endif
43
77170988
ACM		 44struct tp_field {
45 int offset;
46 union {
47 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
48 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
49 };
50};
51
52#define TP_UINT_FIELD(bits) \
53static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
54{ \
55d43bca
DA		 55 u##bits value; \
56 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
57 return value; \
77170988
ACM		 58}
59
60TP_UINT_FIELD(8);
61TP_UINT_FIELD(16);
62TP_UINT_FIELD(32);
63TP_UINT_FIELD(64);
64
65#define TP_UINT_FIELD__SWAPPED(bits) \
66static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
67{ \
55d43bca
DA		 68 u##bits value; \
69 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
77170988
ACM		 70 return bswap_##bits(value);\
71}
72
73TP_UINT_FIELD__SWAPPED(16);
74TP_UINT_FIELD__SWAPPED(32);
75TP_UINT_FIELD__SWAPPED(64);
76
77static int tp_field__init_uint(struct tp_field *field,
78 struct format_field *format_field,
79 bool needs_swap)
80{
81 field->offset = format_field->offset;
82
83 switch (format_field->size) {
84 case 1:
85 field->integer = tp_field__u8;
86 break;
87 case 2:
88 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
89 break;
90 case 4:
91 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
92 break;
93 case 8:
94 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
95 break;
96 default:
97 return -1;
98 }
99
100 return 0;
101}
102
103static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
104{
105 return sample->raw_data + field->offset;
106}
107
108static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
109{
110 field->offset = format_field->offset;
111 field->pointer = tp_field__ptr;
112 return 0;
113}
114
115struct syscall_tp {
116 struct tp_field id;
117 union {
118 struct tp_field args, ret;
119 };
120};
121
122static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
123 struct tp_field *field,
124 const char *name)
125{
126 struct format_field *format_field = perf_evsel__field(evsel, name);
127
128 if (format_field == NULL)
129 return -1;
130
131 return tp_field__init_uint(field, format_field, evsel->needs_swap);
132}
133
134#define perf_evsel__init_sc_tp_uint_field(evsel, name) \
135 ({ struct syscall_tp *sc = evsel->priv;\
136 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
137
138static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
139 struct tp_field *field,
140 const char *name)
141{
142 struct format_field *format_field = perf_evsel__field(evsel, name);
143
144 if (format_field == NULL)
145 return -1;
146
147 return tp_field__init_ptr(field, format_field);
148}
149
150#define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
151 ({ struct syscall_tp *sc = evsel->priv;\
152 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
153
154static void perf_evsel__delete_priv(struct perf_evsel *evsel)
155{
04662523 156 zfree(&evsel->priv);
77170988
ACM		 157 perf_evsel__delete(evsel);
158}
159
96695d44
NK		 160static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
161{
162 evsel->priv = malloc(sizeof(struct syscall_tp));
163 if (evsel->priv != NULL) {
164 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
165 goto out_delete;
166
167 evsel->handler = handler;
168 return 0;
169 }
170
171 return -ENOMEM;
172
173out_delete:
04662523 174 zfree(&evsel->priv);
96695d44
NK		 175 return -ENOENT;
176}
177
ef503831 178static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
77170988 179{
ef503831 180 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
77170988 181
9aca7f17
DA		 182 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
183 if (evsel == NULL)
184 evsel = perf_evsel__newtp("syscalls", direction);
185
77170988 186 if (evsel) {
96695d44 187 if (perf_evsel__init_syscall_tp(evsel, handler))
77170988 188 goto out_delete;
77170988
ACM		 189 }
190
191 return evsel;
192
193out_delete:
194 perf_evsel__delete_priv(evsel);
195 return NULL;
196}
197
198#define perf_evsel__sc_tp_uint(evsel, name, sample) \
199 ({ struct syscall_tp *fields = evsel->priv; \
200 fields->name.integer(&fields->name, sample); })
201
202#define perf_evsel__sc_tp_ptr(evsel, name, sample) \
203 ({ struct syscall_tp *fields = evsel->priv; \
204 fields->name.pointer(&fields->name, sample); })
205
206static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
207 void *sys_enter_handler,
208 void *sys_exit_handler)
209{
210 int ret = -1;
77170988
ACM		 211 struct perf_evsel *sys_enter, *sys_exit;
212
ef503831 213 sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
77170988
ACM		 214 if (sys_enter == NULL)
215 goto out;
216
217 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
218 goto out_delete_sys_enter;
219
ef503831 220 sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
77170988
ACM		 221 if (sys_exit == NULL)
222 goto out_delete_sys_enter;
223
224 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
225 goto out_delete_sys_exit;
226
227 perf_evlist__add(evlist, sys_enter);
228 perf_evlist__add(evlist, sys_exit);
229
230 ret = 0;
231out:
232 return ret;
233
234out_delete_sys_exit:
235 perf_evsel__delete_priv(sys_exit);
236out_delete_sys_enter:
237 perf_evsel__delete_priv(sys_enter);
238 goto out;
239}
240
241
01533e97
ACM		 242struct syscall_arg {
243 unsigned long val;
75b757ca
ACM		 244 struct thread *thread;
245 struct trace *trace;
1f115cb7 246 void *parm;
01533e97
ACM		 247 u8 idx;
248 u8 mask;
249};
250
1f115cb7 251struct strarray {
03e3adc9 252 int offset;
1f115cb7
ACM		 253 int nr_entries;
254 const char **entries;
255};
256
257#define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
258 .nr_entries = ARRAY_SIZE(array), \
259 .entries = array, \
260}
261
03e3adc9
ACM		 262#define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
263 .offset = off, \
264 .nr_entries = ARRAY_SIZE(array), \
265 .entries = array, \
266}
267
975b7c2f
ACM		 268static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
269 const char *intfmt,
270 struct syscall_arg *arg)
1f115cb7 271{
1f115cb7 272 struct strarray *sa = arg->parm;
03e3adc9 273 int idx = arg->val - sa->offset;
1f115cb7
ACM		 274
275 if (idx < 0 || idx >= sa->nr_entries)
975b7c2f 276 return scnprintf(bf, size, intfmt, arg->val);
1f115cb7
ACM		 277
278 return scnprintf(bf, size, "%s", sa->entries[idx]);
279}
280
975b7c2f
ACM		 281static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
282 struct syscall_arg *arg)
283{
284 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
285}
286
1f115cb7
ACM		 287#define SCA_STRARRAY syscall_arg__scnprintf_strarray
288
844ae5b4
ACM		 289#if defined(__i386__) || defined(__x86_64__)
290/*
291 * FIXME: Make this available to all arches as soon as the ioctl beautifier
292 * gets rewritten to support all arches.
293 */
78645cf3
ACM		 294static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
295 struct syscall_arg *arg)
296{
297 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
298}
299
300#define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
844ae5b4 301#endif /* defined(__i386__) || defined(__x86_64__) */
78645cf3 302
75b757ca
ACM		 303static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
304 struct syscall_arg *arg);
305
306#define SCA_FD syscall_arg__scnprintf_fd
307
308static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
309 struct syscall_arg *arg)
310{
311 int fd = arg->val;
312
313 if (fd == AT_FDCWD)
314 return scnprintf(bf, size, "CWD");
315
316 return syscall_arg__scnprintf_fd(bf, size, arg);
317}
318
319#define SCA_FDAT syscall_arg__scnprintf_fd_at
320
321static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
322 struct syscall_arg *arg);
323
324#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
325
6e7eeb51 326static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
01533e97 327 struct syscall_arg *arg)
13d4ff3e 328{
01533e97 329 return scnprintf(bf, size, "%#lx", arg->val);
13d4ff3e
ACM		 330}
331
beccb2b5
ACM		 332#define SCA_HEX syscall_arg__scnprintf_hex
333
6e7eeb51 334static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
01533e97 335 struct syscall_arg *arg)
ae685380 336{
01533e97 337 int printed = 0, prot = arg->val;
ae685380
ACM		 338
339 if (prot == PROT_NONE)
340 return scnprintf(bf, size, "NONE");
341#define P_MMAP_PROT(n) \
342 if (prot & PROT_##n) { \
343 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
344 prot &= ~PROT_##n; \
345 }
346
347 P_MMAP_PROT(EXEC);
348 P_MMAP_PROT(READ);
349 P_MMAP_PROT(WRITE);
350#ifdef PROT_SEM
351 P_MMAP_PROT(SEM);
352#endif
353 P_MMAP_PROT(GROWSDOWN);
354 P_MMAP_PROT(GROWSUP);
355#undef P_MMAP_PROT
356
357 if (prot)
358 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
359
360 return printed;
361}
362
363#define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
364
6e7eeb51 365static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
01533e97 366 struct syscall_arg *arg)
941557e0 367{
01533e97 368 int printed = 0, flags = arg->val;
941557e0
ACM		 369
370#define P_MMAP_FLAG(n) \
371 if (flags & MAP_##n) { \
372 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
373 flags &= ~MAP_##n; \
374 }
375
376 P_MMAP_FLAG(SHARED);
377 P_MMAP_FLAG(PRIVATE);
41817815 378#ifdef MAP_32BIT
941557e0 379 P_MMAP_FLAG(32BIT);
41817815 380#endif
941557e0
ACM		 381 P_MMAP_FLAG(ANONYMOUS);
382 P_MMAP_FLAG(DENYWRITE);
383 P_MMAP_FLAG(EXECUTABLE);
384 P_MMAP_FLAG(FILE);
385 P_MMAP_FLAG(FIXED);
386 P_MMAP_FLAG(GROWSDOWN);
f2935f3e 387#ifdef MAP_HUGETLB
941557e0 388 P_MMAP_FLAG(HUGETLB);
f2935f3e 389#endif
941557e0
ACM		 390 P_MMAP_FLAG(LOCKED);
391 P_MMAP_FLAG(NONBLOCK);
392 P_MMAP_FLAG(NORESERVE);
393 P_MMAP_FLAG(POPULATE);
394 P_MMAP_FLAG(STACK);
395#ifdef MAP_UNINITIALIZED
396 P_MMAP_FLAG(UNINITIALIZED);
397#endif
398#undef P_MMAP_FLAG
399
400 if (flags)
401 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
402
403 return printed;
404}
405
406#define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
407
86998dda
AS		 408static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
409 struct syscall_arg *arg)
410{
411 int printed = 0, flags = arg->val;
412
413#define P_MREMAP_FLAG(n) \
414 if (flags & MREMAP_##n) { \
415 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
416 flags &= ~MREMAP_##n; \
417 }
418
419 P_MREMAP_FLAG(MAYMOVE);
420#ifdef MREMAP_FIXED
421 P_MREMAP_FLAG(FIXED);
422#endif
423#undef P_MREMAP_FLAG
424
425 if (flags)
426 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
427
428 return printed;
429}
430
431#define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
432
6e7eeb51 433static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
01533e97 434 struct syscall_arg *arg)
9e9716d1 435{
01533e97 436 int behavior = arg->val;
9e9716d1
ACM		 437
438 switch (behavior) {
439#define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
440 P_MADV_BHV(NORMAL);
441 P_MADV_BHV(RANDOM);
442 P_MADV_BHV(SEQUENTIAL);
443 P_MADV_BHV(WILLNEED);
444 P_MADV_BHV(DONTNEED);
445 P_MADV_BHV(REMOVE);
446 P_MADV_BHV(DONTFORK);
447 P_MADV_BHV(DOFORK);
448 P_MADV_BHV(HWPOISON);
449#ifdef MADV_SOFT_OFFLINE
450 P_MADV_BHV(SOFT_OFFLINE);
451#endif
452 P_MADV_BHV(MERGEABLE);
453 P_MADV_BHV(UNMERGEABLE);
f2935f3e 454#ifdef MADV_HUGEPAGE
9e9716d1 455 P_MADV_BHV(HUGEPAGE);
f2935f3e
DA		 456#endif
457#ifdef MADV_NOHUGEPAGE
9e9716d1 458 P_MADV_BHV(NOHUGEPAGE);
f2935f3e 459#endif
9e9716d1
ACM		 460#ifdef MADV_DONTDUMP
461 P_MADV_BHV(DONTDUMP);
462#endif
463#ifdef MADV_DODUMP
464 P_MADV_BHV(DODUMP);
465#endif
466#undef P_MADV_PHV
467 default: break;
468 }
469
470 return scnprintf(bf, size, "%#x", behavior);
471}
472
473#define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
474
5cea6ff2
ACM		 475static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
476 struct syscall_arg *arg)
477{
478 int printed = 0, op = arg->val;
479
480 if (op == 0)
481 return scnprintf(bf, size, "NONE");
482#define P_CMD(cmd) \
483 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
484 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
485 op &= ~LOCK_##cmd; \
486 }
487
488 P_CMD(SH);
489 P_CMD(EX);
490 P_CMD(NB);
491 P_CMD(UN);
492 P_CMD(MAND);
493 P_CMD(RW);
494 P_CMD(READ);
495 P_CMD(WRITE);
496#undef P_OP
497
498 if (op)
499 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
500
501 return printed;
502}
503
504#define SCA_FLOCK syscall_arg__scnprintf_flock
505
01533e97 506static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
f9da0b0c
ACM		 507{
508 enum syscall_futex_args {
509 SCF_UADDR = (1 << 0),
510 SCF_OP = (1 << 1),
511 SCF_VAL = (1 << 2),
512 SCF_TIMEOUT = (1 << 3),
513 SCF_UADDR2 = (1 << 4),
514 SCF_VAL3 = (1 << 5),
515 };
01533e97 516 int op = arg->val;
f9da0b0c
ACM		 517 int cmd = op & FUTEX_CMD_MASK;
518 size_t printed = 0;
519
520 switch (cmd) {
521#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
01533e97
ACM		 522 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
523 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
524 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
525 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
526 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
527 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
f9da0b0c 528 P_FUTEX_OP(WAKE_OP); break;
01533e97
ACM		 529 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
530 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
531 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
532 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
533 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
f9da0b0c
ACM		 534 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
535 default: printed = scnprintf(bf, size, "%#x", cmd); break;
536 }
537
538 if (op & FUTEX_PRIVATE_FLAG)
539 printed += scnprintf(bf + printed, size - printed, "|PRIV");
540
541 if (op & FUTEX_CLOCK_REALTIME)
542 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
543
544 return printed;
545}
546
efe6b882
ACM		 547#define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
548
03e3adc9
ACM		 549static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
550static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
eac032c5 551
1f115cb7
ACM		 552static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
553static DEFINE_STRARRAY(itimers);
554
efe6b882
ACM		 555static const char *whences[] = { "SET", "CUR", "END",
556#ifdef SEEK_DATA
557"DATA",
558#endif
559#ifdef SEEK_HOLE
560"HOLE",
561#endif
562};
563static DEFINE_STRARRAY(whences);
f9da0b0c 564
80f587d5
ACM		 565static const char *fcntl_cmds[] = {
566 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
567 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
568 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
569 "F_GETOWNER_UIDS",
570};
571static DEFINE_STRARRAY(fcntl_cmds);
572
c045bf02
ACM		 573static const char *rlimit_resources[] = {
574 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
575 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
576 "RTTIME",
577};
578static DEFINE_STRARRAY(rlimit_resources);
579
eb5b1b14
ACM		 580static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
581static DEFINE_STRARRAY(sighow);
582
4f8c1b74
DA		 583static const char *clockid[] = {
584 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
585 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
586};
587static DEFINE_STRARRAY(clockid);
588
e10bce81
ACM		 589static const char *socket_families[] = {
590 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
591 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
592 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
593 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
594 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
595 "ALG", "NFC", "VSOCK",
596};
597static DEFINE_STRARRAY(socket_families);
598
a28b24b2
ACM		 599#ifndef SOCK_TYPE_MASK
600#define SOCK_TYPE_MASK 0xf
601#endif
602
603static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
604 struct syscall_arg *arg)
605{
606 size_t printed;
607 int type = arg->val,
608 flags = type & ~SOCK_TYPE_MASK;
609
610 type &= SOCK_TYPE_MASK;
611 /*
612 * Can't use a strarray, MIPS may override for ABI reasons.
613 */
614 switch (type) {
615#define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
616 P_SK_TYPE(STREAM);
617 P_SK_TYPE(DGRAM);
618 P_SK_TYPE(RAW);
619 P_SK_TYPE(RDM);
620 P_SK_TYPE(SEQPACKET);
621 P_SK_TYPE(DCCP);
622 P_SK_TYPE(PACKET);
623#undef P_SK_TYPE
624 default:
625 printed = scnprintf(bf, size, "%#x", type);
626 }
627
628#define P_SK_FLAG(n) \
629 if (flags & SOCK_##n) { \
630 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
631 flags &= ~SOCK_##n; \
632 }
633
634 P_SK_FLAG(CLOEXEC);
635 P_SK_FLAG(NONBLOCK);
636#undef P_SK_FLAG
637
638 if (flags)
639 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
640
641 return printed;
642}
643
644#define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
645
b2cc99fd
ACM		 646#ifndef MSG_PROBE
647#define MSG_PROBE 0x10
648#endif
b6e8f8f4
DA		 649#ifndef MSG_WAITFORONE
650#define MSG_WAITFORONE 0x10000
651#endif
b2cc99fd
ACM		 652#ifndef MSG_SENDPAGE_NOTLAST
653#define MSG_SENDPAGE_NOTLAST 0x20000
654#endif
655#ifndef MSG_FASTOPEN
656#define MSG_FASTOPEN 0x20000000
657#endif
658
659static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
660 struct syscall_arg *arg)
661{
662 int printed = 0, flags = arg->val;
663
664 if (flags == 0)
665 return scnprintf(bf, size, "NONE");
666#define P_MSG_FLAG(n) \
667 if (flags & MSG_##n) { \
668 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
669 flags &= ~MSG_##n; \
670 }
671
672 P_MSG_FLAG(OOB);
673 P_MSG_FLAG(PEEK);
674 P_MSG_FLAG(DONTROUTE);
675 P_MSG_FLAG(TRYHARD);
676 P_MSG_FLAG(CTRUNC);
677 P_MSG_FLAG(PROBE);
678 P_MSG_FLAG(TRUNC);
679 P_MSG_FLAG(DONTWAIT);
680 P_MSG_FLAG(EOR);
681 P_MSG_FLAG(WAITALL);
682 P_MSG_FLAG(FIN);
683 P_MSG_FLAG(SYN);
684 P_MSG_FLAG(CONFIRM);
685 P_MSG_FLAG(RST);
686 P_MSG_FLAG(ERRQUEUE);
687 P_MSG_FLAG(NOSIGNAL);
688 P_MSG_FLAG(MORE);
689 P_MSG_FLAG(WAITFORONE);
690 P_MSG_FLAG(SENDPAGE_NOTLAST);
691 P_MSG_FLAG(FASTOPEN);
692 P_MSG_FLAG(CMSG_CLOEXEC);
693#undef P_MSG_FLAG
694
695 if (flags)
696 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
697
698 return printed;
699}
700
701#define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
702
51108999
ACM		 703static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
704 struct syscall_arg *arg)
705{
706 size_t printed = 0;
707 int mode = arg->val;
708
709 if (mode == F_OK) /* 0 */
710 return scnprintf(bf, size, "F");
711#define P_MODE(n) \
712 if (mode & n##_OK) { \
713 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
714 mode &= ~n##_OK; \
715 }
716
717 P_MODE(R);
718 P_MODE(W);
719 P_MODE(X);
720#undef P_MODE
721
722 if (mode)
723 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
724
725 return printed;
726}
727
728#define SCA_ACCMODE syscall_arg__scnprintf_access_mode
729
be65a89a 730static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
01533e97 731 struct syscall_arg *arg)
be65a89a 732{
01533e97 733 int printed = 0, flags = arg->val;
be65a89a
ACM		 734
735 if (!(flags & O_CREAT))
01533e97 736 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
be65a89a
ACM		 737
738 if (flags == 0)
739 return scnprintf(bf, size, "RDONLY");
740#define P_FLAG(n) \
741 if (flags & O_##n) { \
742 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
743 flags &= ~O_##n; \
744 }
745
746 P_FLAG(APPEND);
747 P_FLAG(ASYNC);
748 P_FLAG(CLOEXEC);
749 P_FLAG(CREAT);
750 P_FLAG(DIRECT);
751 P_FLAG(DIRECTORY);
752 P_FLAG(EXCL);
753 P_FLAG(LARGEFILE);
754 P_FLAG(NOATIME);
755 P_FLAG(NOCTTY);
756#ifdef O_NONBLOCK
757 P_FLAG(NONBLOCK);
758#elif O_NDELAY
759 P_FLAG(NDELAY);
760#endif
761#ifdef O_PATH
762 P_FLAG(PATH);
763#endif
764 P_FLAG(RDWR);
765#ifdef O_DSYNC
766 if ((flags & O_SYNC) == O_SYNC)
767 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
768 else {
769 P_FLAG(DSYNC);
770 }
771#else
772 P_FLAG(SYNC);
773#endif
774 P_FLAG(TRUNC);
775 P_FLAG(WRONLY);
776#undef P_FLAG
777
778 if (flags)
779 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
780
781 return printed;
782}
783
784#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
785
49af9e93
ACM		 786static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
787 struct syscall_arg *arg)
788{
789 int printed = 0, flags = arg->val;
790
791 if (flags == 0)
792 return scnprintf(bf, size, "NONE");
793#define P_FLAG(n) \
794 if (flags & EFD_##n) { \
795 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
796 flags &= ~EFD_##n; \
797 }
798
799 P_FLAG(SEMAPHORE);
800 P_FLAG(CLOEXEC);
801 P_FLAG(NONBLOCK);
802#undef P_FLAG
803
804 if (flags)
805 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
806
807 return printed;
808}
809
810#define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
811
46cce19b
ACM		 812static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
813 struct syscall_arg *arg)
814{
815 int printed = 0, flags = arg->val;
816
817#define P_FLAG(n) \
818 if (flags & O_##n) { \
819 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
820 flags &= ~O_##n; \
821 }
822
823 P_FLAG(CLOEXEC);
824 P_FLAG(NONBLOCK);
825#undef P_FLAG
826
827 if (flags)
828 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
829
830 return printed;
831}
832
833#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
834
8bad5b0a
ACM		 835static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
836{
837 int sig = arg->val;
838
839 switch (sig) {
840#define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
841 P_SIGNUM(HUP);
842 P_SIGNUM(INT);
843 P_SIGNUM(QUIT);
844 P_SIGNUM(ILL);
845 P_SIGNUM(TRAP);
846 P_SIGNUM(ABRT);
847 P_SIGNUM(BUS);
848 P_SIGNUM(FPE);
849 P_SIGNUM(KILL);
850 P_SIGNUM(USR1);
851 P_SIGNUM(SEGV);
852 P_SIGNUM(USR2);
853 P_SIGNUM(PIPE);
854 P_SIGNUM(ALRM);
855 P_SIGNUM(TERM);
8bad5b0a
ACM		 856 P_SIGNUM(CHLD);
857 P_SIGNUM(CONT);
858 P_SIGNUM(STOP);
859 P_SIGNUM(TSTP);
860 P_SIGNUM(TTIN);
861 P_SIGNUM(TTOU);
862 P_SIGNUM(URG);
863 P_SIGNUM(XCPU);
864 P_SIGNUM(XFSZ);
865 P_SIGNUM(VTALRM);
866 P_SIGNUM(PROF);
867 P_SIGNUM(WINCH);
868 P_SIGNUM(IO);
869 P_SIGNUM(PWR);
870 P_SIGNUM(SYS);
02c5bb4a
BH		 871#ifdef SIGEMT
872 P_SIGNUM(EMT);
873#endif
874#ifdef SIGSTKFLT
875 P_SIGNUM(STKFLT);
876#endif
877#ifdef SIGSWI
878 P_SIGNUM(SWI);
879#endif
8bad5b0a
ACM		 880 default: break;
881 }
882
883 return scnprintf(bf, size, "%#x", sig);
884}
885
886#define SCA_SIGNUM syscall_arg__scnprintf_signum
887
844ae5b4
ACM		 888#if defined(__i386__) || defined(__x86_64__)
889/*
890 * FIXME: Make this available to all arches.
891 */
78645cf3
ACM		 892#define TCGETS 0x5401
893
894static const char *tioctls[] = {
895 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
896 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
897 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
898 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
899 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
900 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
901 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
902 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
903 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
904 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
905 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
906 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
907 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
908 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
909 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
910};
911
912static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
844ae5b4 913#endif /* defined(__i386__) || defined(__x86_64__) */
78645cf3 914
453350dd
ACM		 915#define STRARRAY(arg, name, array) \
916 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
917 .arg_parm = { [arg] = &strarray__##array, }
918
514f1c67
ACM		 919static struct syscall_fmt {
920 const char *name;
aec1930b 921 const char *alias;
01533e97 922 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
1f115cb7 923 void *arg_parm[6];
514f1c67
ACM		 924 bool errmsg;
925 bool timeout;
04b34729 926 bool hexret;
514f1c67 927} syscall_fmts[] = {
51108999
ACM		 928 { .name = "access", .errmsg = true,
929 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
aec1930b 930 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
beccb2b5
ACM		 931 { .name = "brk", .hexret = true,
932 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
4f8c1b74 933 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
75b757ca 934 { .name = "close", .errmsg = true,
48000a1a 935 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
a14bb860 936 { .name = "connect", .errmsg = true, },
75b757ca 937 { .name = "dup", .errmsg = true,
48000a1a 938 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 939 { .name = "dup2", .errmsg = true,
48000a1a 940 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 941 { .name = "dup3", .errmsg = true,
48000a1a 942 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd 943 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
49af9e93
ACM		 944 { .name = "eventfd2", .errmsg = true,
945 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
75b757ca
ACM		 946 { .name = "faccessat", .errmsg = true,
947 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
948 { .name = "fadvise64", .errmsg = true,
48000a1a 949 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 950 { .name = "fallocate", .errmsg = true,
48000a1a 951 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 952 { .name = "fchdir", .errmsg = true,
48000a1a 953 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 954 { .name = "fchmod", .errmsg = true,
48000a1a 955 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 956 { .name = "fchmodat", .errmsg = true,
48000a1a 957 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
75b757ca 958 { .name = "fchown", .errmsg = true,
48000a1a 959 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 960 { .name = "fchownat", .errmsg = true,
48000a1a 961 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
75b757ca
ACM		 962 { .name = "fcntl", .errmsg = true,
963 .arg_scnprintf = { [0] = SCA_FD, /* fd */
964 [1] = SCA_STRARRAY, /* cmd */ },
965 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
966 { .name = "fdatasync", .errmsg = true,
48000a1a 967 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
5cea6ff2 968 { .name = "flock", .errmsg = true,
75b757ca
ACM		 969 .arg_scnprintf = { [0] = SCA_FD, /* fd */
970 [1] = SCA_FLOCK, /* cmd */ }, },
971 { .name = "fsetxattr", .errmsg = true,
48000a1a 972 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 973 { .name = "fstat", .errmsg = true, .alias = "newfstat",
48000a1a 974 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 975 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
48000a1a 976 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
75b757ca 977 { .name = "fstatfs", .errmsg = true,
48000a1a 978 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 979 { .name = "fsync", .errmsg = true,
48000a1a 980 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 981 { .name = "ftruncate", .errmsg = true,
48000a1a 982 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
f9da0b0c
ACM		 983 { .name = "futex", .errmsg = true,
984 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
75b757ca 985 { .name = "futimesat", .errmsg = true,
48000a1a 986 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
75b757ca 987 { .name = "getdents", .errmsg = true,
48000a1a 988 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 989 { .name = "getdents64", .errmsg = true,
48000a1a 990 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd
ACM		 991 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
992 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
beccb2b5 993 { .name = "ioctl", .errmsg = true,
48000a1a 994 .arg_scnprintf = { [0] = SCA_FD, /* fd */
844ae5b4
ACM		 995#if defined(__i386__) || defined(__x86_64__)
996/*
997 * FIXME: Make this available to all arches.
998 */
78645cf3
ACM		 999 [1] = SCA_STRHEXARRAY, /* cmd */
1000 [2] = SCA_HEX, /* arg */ },
1001 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
844ae5b4
ACM		 1002#else
1003 [2] = SCA_HEX, /* arg */ }, },
1004#endif
8bad5b0a
ACM		 1005 { .name = "kill", .errmsg = true,
1006 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
75b757ca 1007 { .name = "linkat", .errmsg = true,
48000a1a 1008 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
75b757ca
ACM		 1009 { .name = "lseek", .errmsg = true,
1010 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1011 [2] = SCA_STRARRAY, /* whence */ },
1012 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
e5959683 1013 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
9e9716d1
ACM		 1014 { .name = "madvise", .errmsg = true,
1015 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1016 [2] = SCA_MADV_BHV, /* behavior */ }, },
75b757ca 1017 { .name = "mkdirat", .errmsg = true,
48000a1a 1018 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
75b757ca 1019 { .name = "mknodat", .errmsg = true,
48000a1a 1020 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
3d903aa7
ACM		 1021 { .name = "mlock", .errmsg = true,
1022 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1023 { .name = "mlockall", .errmsg = true,
1024 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
beccb2b5 1025 { .name = "mmap", .hexret = true,
ae685380 1026 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
941557e0 1027 [2] = SCA_MMAP_PROT, /* prot */
73faab3a
NK		 1028 [3] = SCA_MMAP_FLAGS, /* flags */
1029 [4] = SCA_FD, /* fd */ }, },
beccb2b5 1030 { .name = "mprotect", .errmsg = true,
ae685380
ACM		 1031 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1032 [2] = SCA_MMAP_PROT, /* prot */ }, },
1033 { .name = "mremap", .hexret = true,
1034 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
86998dda 1035 [3] = SCA_MREMAP_FLAGS, /* flags */
ae685380 1036 [4] = SCA_HEX, /* new_addr */ }, },
3d903aa7
ACM		 1037 { .name = "munlock", .errmsg = true,
1038 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
beccb2b5
ACM		 1039 { .name = "munmap", .errmsg = true,
1040 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
75b757ca 1041 { .name = "name_to_handle_at", .errmsg = true,
48000a1a 1042 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
75b757ca 1043 { .name = "newfstatat", .errmsg = true,
48000a1a 1044 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
be65a89a
ACM		 1045 { .name = "open", .errmsg = true,
1046 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
31cd3855 1047 { .name = "open_by_handle_at", .errmsg = true,
75b757ca
ACM		 1048 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1049 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
31cd3855 1050 { .name = "openat", .errmsg = true,
75b757ca
ACM		 1051 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1052 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
46cce19b
ACM		 1053 { .name = "pipe2", .errmsg = true,
1054 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
aec1930b
ACM		 1055 { .name = "poll", .errmsg = true, .timeout = true, },
1056 { .name = "ppoll", .errmsg = true, .timeout = true, },
75b757ca 1057 { .name = "pread", .errmsg = true, .alias = "pread64",
48000a1a 1058 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 1059 { .name = "preadv", .errmsg = true, .alias = "pread",
48000a1a 1060 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd 1061 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
75b757ca 1062 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
48000a1a 1063 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 1064 { .name = "pwritev", .errmsg = true,
48000a1a 1065 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 1066 { .name = "read", .errmsg = true,
48000a1a 1067 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 1068 { .name = "readlinkat", .errmsg = true,
48000a1a 1069 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
75b757ca 1070 { .name = "readv", .errmsg = true,
48000a1a 1071 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
b2cc99fd
ACM		 1072 { .name = "recvfrom", .errmsg = true,
1073 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1074 { .name = "recvmmsg", .errmsg = true,
1075 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1076 { .name = "recvmsg", .errmsg = true,
1077 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
75b757ca 1078 { .name = "renameat", .errmsg = true,
48000a1a 1079 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
8bad5b0a
ACM		 1080 { .name = "rt_sigaction", .errmsg = true,
1081 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
453350dd 1082 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
8bad5b0a
ACM		 1083 { .name = "rt_sigqueueinfo", .errmsg = true,
1084 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1085 { .name = "rt_tgsigqueueinfo", .errmsg = true,
1086 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
aec1930b 1087 { .name = "select", .errmsg = true, .timeout = true, },
b2cc99fd
ACM		 1088 { .name = "sendmmsg", .errmsg = true,
1089 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1090 { .name = "sendmsg", .errmsg = true,
1091 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1092 { .name = "sendto", .errmsg = true,
1093 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
453350dd
ACM		 1094 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1095 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
75b757ca 1096 { .name = "shutdown", .errmsg = true,
48000a1a 1097 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
e10bce81 1098 { .name = "socket", .errmsg = true,
a28b24b2
ACM		 1099 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1100 [1] = SCA_SK_TYPE, /* type */ },
07120aa5
ACM		 1101 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1102 { .name = "socketpair", .errmsg = true,
1103 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1104 [1] = SCA_SK_TYPE, /* type */ },
e10bce81 1105 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
aec1930b 1106 { .name = "stat", .errmsg = true, .alias = "newstat", },
75b757ca 1107 { .name = "symlinkat", .errmsg = true,
48000a1a 1108 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
8bad5b0a
ACM		 1109 { .name = "tgkill", .errmsg = true,
1110 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1111 { .name = "tkill", .errmsg = true,
1112 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
e5959683 1113 { .name = "uname", .errmsg = true, .alias = "newuname", },
75b757ca
ACM		 1114 { .name = "unlinkat", .errmsg = true,
1115 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1116 { .name = "utimensat", .errmsg = true,
1117 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
1118 { .name = "write", .errmsg = true,
48000a1a 1119 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
75b757ca 1120 { .name = "writev", .errmsg = true,
48000a1a 1121 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
514f1c67
ACM		 1122};
1123
1124static int syscall_fmt__cmp(const void *name, const void *fmtp)
1125{
1126 const struct syscall_fmt *fmt = fmtp;
1127 return strcmp(name, fmt->name);
1128}
1129
1130static struct syscall_fmt *syscall_fmt__find(const char *name)
1131{
1132 const int nmemb = ARRAY_SIZE(syscall_fmts);
1133 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1134}
1135
1136struct syscall {
1137 struct event_format *tp_format;
f208bd8d
ACM		 1138 int nr_args;
1139 struct format_field *args;
514f1c67 1140 const char *name;
2ae3a312 1141 bool filtered;
5089f20e 1142 bool is_exit;
514f1c67 1143 struct syscall_fmt *fmt;
01533e97 1144 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1f115cb7 1145 void **arg_parm;
514f1c67
ACM		 1146};
1147
60c907ab
ACM		 1148static size_t fprintf_duration(unsigned long t, FILE *fp)
1149{
1150 double duration = (double)t / NSEC_PER_MSEC;
1151 size_t printed = fprintf(fp, "(");
1152
1153 if (duration >= 1.0)
1154 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1155 else if (duration >= 0.01)
1156 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1157 else
1158 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
c24ff998 1159 return printed + fprintf(fp, "): ");
60c907ab
ACM		 1160}
1161
752fde44
ACM		 1162struct thread_trace {
1163 u64 entry_time;
1164 u64 exit_time;
1165 bool entry_pending;
efd5745e 1166 unsigned long nr_events;
a2ea67d7 1167 unsigned long pfmaj, pfmin;
752fde44 1168 char *entry_str;
1302d88e 1169 double runtime_ms;
75b757ca
ACM		 1170 struct {
1171 int max;
1172 char **table;
1173 } paths;
bf2575c1
DA		 1174
1175 struct intlist *syscall_stats;
752fde44
ACM		 1176};
1177
1178static struct thread_trace *thread_trace__new(void)
1179{
75b757ca
ACM		 1180 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1181
1182 if (ttrace)
1183 ttrace->paths.max = -1;
1184
bf2575c1
DA		 1185 ttrace->syscall_stats = intlist__new(NULL);
1186
75b757ca 1187 return ttrace;
752fde44
ACM		 1188}
1189
c24ff998 1190static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
752fde44 1191{
efd5745e
ACM		 1192 struct thread_trace *ttrace;
1193
752fde44
ACM		 1194 if (thread == NULL)
1195 goto fail;
1196
89dceb22
NK		 1197 if (thread__priv(thread) == NULL)
1198 thread__set_priv(thread, thread_trace__new());
48000a1a 1199
89dceb22 1200 if (thread__priv(thread) == NULL)
752fde44
ACM		 1201 goto fail;
1202
89dceb22 1203 ttrace = thread__priv(thread);
efd5745e
ACM		 1204 ++ttrace->nr_events;
1205
1206 return ttrace;
752fde44 1207fail:
c24ff998 1208 color_fprintf(fp, PERF_COLOR_RED,
752fde44
ACM		 1209 "WARNING: not enough memory, dropping samples!\n");
1210 return NULL;
1211}
1212
598d02c5
SF		 1213#define TRACE_PFMAJ (1 << 0)
1214#define TRACE_PFMIN (1 << 1)
1215
514f1c67 1216struct trace {
c24ff998 1217 struct perf_tool tool;
c522739d
ACM		 1218 struct {
1219 int machine;
1220 int open_id;
1221 } audit;
514f1c67
ACM		 1222 struct {
1223 int max;
1224 struct syscall *table;
1225 } syscalls;
b4006796 1226 struct record_opts opts;
14a052df 1227 struct perf_evlist *evlist;
8fb598e5 1228 struct machine *host;
e596663e 1229 struct thread *current;
752fde44 1230 u64 base_time;
c24ff998 1231 FILE *output;
efd5745e 1232 unsigned long nr_events;
b059efdf 1233 struct strlist *ev_qualifier;
c522739d 1234 const char *last_vfs_getname;
bdc89661
DA		 1235 struct intlist *tid_list;
1236 struct intlist *pid_list;
f078c385
ACM		 1237 struct {
1238 size_t nr;
1239 pid_t *entries;
1240 } filter_pids;
98eafce6
ACM		 1241 double duration_filter;
1242 double runtime_ms;
1243 struct {
1244 u64 vfs_getname,
1245 proc_getname;
1246 } stats;
1247 bool not_ev_qualifier;
1248 bool live;
1249 bool full_time;
1302d88e 1250 bool sched;
752fde44 1251 bool multiple_threads;
bf2575c1 1252 bool summary;
fd2eabaf 1253 bool summary_only;
50c95cbd 1254 bool show_comm;
c522739d 1255 bool show_tool_stats;
e281a960 1256 bool trace_syscalls;
e366a6d8 1257 bool force;
598d02c5 1258 int trace_pgfaults;
514f1c67
ACM		 1259};
1260
97119f37 1261static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
75b757ca 1262{
89dceb22 1263 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1264
1265 if (fd > ttrace->paths.max) {
1266 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1267
1268 if (npath == NULL)
1269 return -1;
1270
1271 if (ttrace->paths.max != -1) {
1272 memset(npath + ttrace->paths.max + 1, 0,
1273 (fd - ttrace->paths.max) * sizeof(char *));
1274 } else {
1275 memset(npath, 0, (fd + 1) * sizeof(char *));
1276 }
1277
1278 ttrace->paths.table = npath;
1279 ttrace->paths.max = fd;
1280 }
1281
1282 ttrace->paths.table[fd] = strdup(pathname);
1283
1284 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1285}
1286
97119f37
ACM		 1287static int thread__read_fd_path(struct thread *thread, int fd)
1288{
1289 char linkname[PATH_MAX], pathname[PATH_MAX];
1290 struct stat st;
1291 int ret;
1292
1293 if (thread->pid_ == thread->tid) {
1294 scnprintf(linkname, sizeof(linkname),
1295 "/proc/%d/fd/%d", thread->pid_, fd);
1296 } else {
1297 scnprintf(linkname, sizeof(linkname),
1298 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1299 }
1300
1301 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1302 return -1;
1303
1304 ret = readlink(linkname, pathname, sizeof(pathname));
1305
1306 if (ret < 0 || ret > st.st_size)
1307 return -1;
1308
1309 pathname[ret] = '\0';
1310 return trace__set_fd_pathname(thread, fd, pathname);
1311}
1312
c522739d
ACM		 1313static const char *thread__fd_path(struct thread *thread, int fd,
1314 struct trace *trace)
75b757ca 1315{
89dceb22 1316 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1317
1318 if (ttrace == NULL)
1319 return NULL;
1320
1321 if (fd < 0)
1322 return NULL;
1323
cdcd1e6b 1324 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
c522739d
ACM		 1325 if (!trace->live)
1326 return NULL;
1327 ++trace->stats.proc_getname;
cdcd1e6b 1328 if (thread__read_fd_path(thread, fd))
c522739d
ACM		 1329 return NULL;
1330 }
75b757ca
ACM		 1331
1332 return ttrace->paths.table[fd];
1333}
1334
1335static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1336 struct syscall_arg *arg)
1337{
1338 int fd = arg->val;
1339 size_t printed = scnprintf(bf, size, "%d", fd);
c522739d 1340 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
75b757ca
ACM		 1341
1342 if (path)
1343 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1344
1345 return printed;
1346}
1347
1348static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1349 struct syscall_arg *arg)
1350{
1351 int fd = arg->val;
1352 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
89dceb22 1353 struct thread_trace *ttrace = thread__priv(arg->thread);
75b757ca 1354
04662523
ACM		 1355 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1356 zfree(&ttrace->paths.table[fd]);
75b757ca
ACM		 1357
1358 return printed;
1359}
1360
ae9ed035
ACM		 1361static bool trace__filter_duration(struct trace *trace, double t)
1362{
1363 return t < (trace->duration_filter * NSEC_PER_MSEC);
1364}
1365
752fde44
ACM		 1366static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1367{
1368 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1369
60c907ab 1370 return fprintf(fp, "%10.3f ", ts);
752fde44
ACM		 1371}
1372
f15eb531 1373static bool done = false;
ba209f85 1374static bool interrupted = false;
f15eb531 1375
ba209f85 1376static void sig_handler(int sig)
f15eb531
NK		 1377{
1378 done = true;
ba209f85 1379 interrupted = sig == SIGINT;
f15eb531
NK		 1380}
1381
752fde44 1382static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
60c907ab 1383 u64 duration, u64 tstamp, FILE *fp)
752fde44
ACM		 1384{
1385 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
60c907ab 1386 printed += fprintf_duration(duration, fp);
752fde44 1387
50c95cbd
ACM		 1388 if (trace->multiple_threads) {
1389 if (trace->show_comm)
1902efe7 1390 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
38051234 1391 printed += fprintf(fp, "%d ", thread->tid);
50c95cbd 1392 }
752fde44
ACM		 1393
1394 return printed;
1395}
1396
c24ff998 1397static int trace__process_event(struct trace *trace, struct machine *machine,
162f0bef 1398 union perf_event *event, struct perf_sample *sample)
752fde44
ACM		 1399{
1400 int ret = 0;
1401
1402 switch (event->header.type) {
1403 case PERF_RECORD_LOST:
c24ff998 1404 color_fprintf(trace->output, PERF_COLOR_RED,
752fde44 1405 "LOST %" PRIu64 " events!\n", event->lost.lost);
162f0bef 1406 ret = machine__process_lost_event(machine, event, sample);
752fde44 1407 default:
162f0bef 1408 ret = machine__process_event(machine, event, sample);
752fde44
ACM		 1409 break;
1410 }
1411
1412 return ret;
1413}
1414
c24ff998 1415static int trace__tool_process(struct perf_tool *tool,
752fde44 1416 union perf_event *event,
162f0bef 1417 struct perf_sample *sample,
752fde44
ACM		 1418 struct machine *machine)
1419{
c24ff998 1420 struct trace *trace = container_of(tool, struct trace, tool);
162f0bef 1421 return trace__process_event(trace, machine, event, sample);
752fde44
ACM		 1422}
1423
1424static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1425{
0a7e6d1b 1426 int err = symbol__init(NULL);
752fde44
ACM		 1427
1428 if (err)
1429 return err;
1430
8fb598e5
DA		 1431 trace->host = machine__new_host();
1432 if (trace->host == NULL)
1433 return -ENOMEM;
752fde44 1434
a33fbd56
ACM		 1435 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1436 evlist->threads, trace__tool_process, false);
752fde44
ACM		 1437 if (err)
1438 symbol__exit();
1439
1440 return err;
1441}
1442
13d4ff3e
ACM		 1443static int syscall__set_arg_fmts(struct syscall *sc)
1444{
1445 struct format_field *field;
1446 int idx = 0;
1447
f208bd8d 1448 sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
13d4ff3e
ACM		 1449 if (sc->arg_scnprintf == NULL)
1450 return -1;
1451
1f115cb7
ACM		 1452 if (sc->fmt)
1453 sc->arg_parm = sc->fmt->arg_parm;
1454
f208bd8d 1455 for (field = sc->args; field; field = field->next) {
beccb2b5
ACM		 1456 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1457 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1458 else if (field->flags & FIELD_IS_POINTER)
13d4ff3e
ACM		 1459 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1460 ++idx;
1461 }
1462
1463 return 0;
1464}
1465
514f1c67
ACM		 1466static int trace__read_syscall_info(struct trace *trace, int id)
1467{
1468 char tp_name[128];
1469 struct syscall *sc;
c522739d 1470 const char *name = audit_syscall_to_name(id, trace->audit.machine);
3a531260
ACM		 1471
1472 if (name == NULL)
1473 return -1;
514f1c67
ACM		 1474
1475 if (id > trace->syscalls.max) {
1476 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1477
1478 if (nsyscalls == NULL)
1479 return -1;
1480
1481 if (trace->syscalls.max != -1) {
1482 memset(nsyscalls + trace->syscalls.max + 1, 0,
1483 (id - trace->syscalls.max) * sizeof(*sc));
1484 } else {
1485 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1486 }
1487
1488 trace->syscalls.table = nsyscalls;
1489 trace->syscalls.max = id;
1490 }
1491
1492 sc = trace->syscalls.table + id;
3a531260 1493 sc->name = name;
2ae3a312 1494
b059efdf
ACM		 1495 if (trace->ev_qualifier) {
1496 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1497
1498 if (!(in ^ trace->not_ev_qualifier)) {
1499 sc->filtered = true;
1500 /*
1501 * No need to do read tracepoint information since this will be
1502 * filtered out.
1503 */
1504 return 0;
1505 }
2ae3a312
ACM		 1506 }
1507
3a531260 1508 sc->fmt = syscall_fmt__find(sc->name);
514f1c67 1509
aec1930b 1510 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
97978b3e 1511 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b
ACM		 1512
1513 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1514 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
97978b3e 1515 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b 1516 }
514f1c67 1517
13d4ff3e
ACM		 1518 if (sc->tp_format == NULL)
1519 return -1;
1520
f208bd8d
ACM		 1521 sc->args = sc->tp_format->format.fields;
1522 sc->nr_args = sc->tp_format->format.nr_fields;
1523 /* drop nr field - not relevant here; does not exist on older kernels */
1524 if (sc->args && strcmp(sc->args->name, "nr") == 0) {
1525 sc->args = sc->args->next;
1526 --sc->nr_args;
1527 }
1528
5089f20e
ACM		 1529 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1530
13d4ff3e 1531 return syscall__set_arg_fmts(sc);
514f1c67
ACM		 1532}
1533
55d43bca
DA		 1534/*
1535 * args is to be interpreted as a series of longs but we need to handle
1536 * 8-byte unaligned accesses. args points to raw_data within the event
1537 * and raw_data is guaranteed to be 8-byte unaligned because it is
1538 * preceded by raw_size which is a u32. So we need to copy args to a temp
1539 * variable to read it. Most notably this avoids extended load instructions
1540 * on unaligned addresses
1541 */
1542
752fde44 1543static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
55d43bca 1544 unsigned char *args, struct trace *trace,
75b757ca 1545 struct thread *thread)
514f1c67 1546{
514f1c67 1547 size_t printed = 0;
55d43bca
DA		 1548 unsigned char *p;
1549 unsigned long val;
514f1c67 1550
f208bd8d 1551 if (sc->args != NULL) {
514f1c67 1552 struct format_field *field;
01533e97
ACM		 1553 u8 bit = 1;
1554 struct syscall_arg arg = {
75b757ca
ACM		 1555 .idx = 0,
1556 .mask = 0,
1557 .trace = trace,
1558 .thread = thread,
01533e97 1559 };
6e7eeb51 1560
f208bd8d 1561 for (field = sc->args; field;
01533e97
ACM		 1562 field = field->next, ++arg.idx, bit <<= 1) {
1563 if (arg.mask & bit)
6e7eeb51 1564 continue;
55d43bca
DA		 1565
1566 /* special care for unaligned accesses */
1567 p = args + sizeof(unsigned long) * arg.idx;
1568 memcpy(&val, p, sizeof(val));
1569
4aa58232
ACM		 1570 /*
1571 * Suppress this argument if its value is zero and
1572 * and we don't have a string associated in an
1573 * strarray for it.
1574 */
55d43bca 1575 if (val == 0 &&
4aa58232
ACM		 1576 !(sc->arg_scnprintf &&
1577 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1578 sc->arg_parm[arg.idx]))
22ae5cf1
ACM		 1579 continue;
1580
752fde44 1581 printed += scnprintf(bf + printed, size - printed,
13d4ff3e 1582 "%s%s: ", printed ? ", " : "", field->name);
01533e97 1583 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
55d43bca 1584 arg.val = val;
1f115cb7
ACM		 1585 if (sc->arg_parm)
1586 arg.parm = sc->arg_parm[arg.idx];
01533e97
ACM		 1587 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1588 size - printed, &arg);
6e7eeb51 1589 } else {
13d4ff3e 1590 printed += scnprintf(bf + printed, size - printed,
55d43bca 1591 "%ld", val);
6e7eeb51 1592 }
514f1c67
ACM		 1593 }
1594 } else {
01533e97
ACM		 1595 int i = 0;
1596
514f1c67 1597 while (i < 6) {
55d43bca
DA		 1598 /* special care for unaligned accesses */
1599 p = args + sizeof(unsigned long) * i;
1600 memcpy(&val, p, sizeof(val));
752fde44
ACM		 1601 printed += scnprintf(bf + printed, size - printed,
1602 "%sarg%d: %ld",
55d43bca 1603 printed ? ", " : "", i, val);
514f1c67
ACM		 1604 ++i;
1605 }
1606 }
1607
1608 return printed;
1609}
1610
ba3d7dee 1611typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1612 union perf_event *event,
ba3d7dee
ACM		 1613 struct perf_sample *sample);
1614
1615static struct syscall *trace__syscall_info(struct trace *trace,
bf2575c1 1616 struct perf_evsel *evsel, int id)
ba3d7dee 1617{
ba3d7dee
ACM		 1618
1619 if (id < 0) {
adaa18bf
ACM		 1620
1621 /*
1622 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1623 * before that, leaving at a higher verbosity level till that is
1624 * explained. Reproduced with plain ftrace with:
1625 *
1626 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1627 * grep "NR -1 " /t/trace_pipe
1628 *
1629 * After generating some load on the machine.
1630 */
1631 if (verbose > 1) {
1632 static u64 n;
1633 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1634 id, perf_evsel__name(evsel), ++n);
1635 }
ba3d7dee
ACM		 1636 return NULL;
1637 }
1638
1639 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1640 trace__read_syscall_info(trace, id))
1641 goto out_cant_read;
1642
1643 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1644 goto out_cant_read;
1645
1646 return &trace->syscalls.table[id];
1647
1648out_cant_read:
7c304ee0
ACM		 1649 if (verbose) {
1650 fprintf(trace->output, "Problems reading syscall %d", id);
1651 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1652 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1653 fputs(" information\n", trace->output);
1654 }
ba3d7dee
ACM		 1655 return NULL;
1656}
1657
bf2575c1
DA		 1658static void thread__update_stats(struct thread_trace *ttrace,
1659 int id, struct perf_sample *sample)
1660{
1661 struct int_node *inode;
1662 struct stats *stats;
1663 u64 duration = 0;
1664
1665 inode = intlist__findnew(ttrace->syscall_stats, id);
1666 if (inode == NULL)
1667 return;
1668
1669 stats = inode->priv;
1670 if (stats == NULL) {
1671 stats = malloc(sizeof(struct stats));
1672 if (stats == NULL)
1673 return;
1674 init_stats(stats);
1675 inode->priv = stats;
1676 }
1677
1678 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1679 duration = sample->time - ttrace->entry_time;
1680
1681 update_stats(stats, duration);
1682}
1683
e596663e
ACM		 1684static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1685{
1686 struct thread_trace *ttrace;
1687 u64 duration;
1688 size_t printed;
1689
1690 if (trace->current == NULL)
1691 return 0;
1692
1693 ttrace = thread__priv(trace->current);
1694
1695 if (!ttrace->entry_pending)
1696 return 0;
1697
1698 duration = sample->time - ttrace->entry_time;
1699
1700 printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1701 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1702 ttrace->entry_pending = false;
1703
1704 return printed;
1705}
1706
ba3d7dee 1707static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1708 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1709 struct perf_sample *sample)
1710{
752fde44 1711 char *msg;
ba3d7dee 1712 void *args;
752fde44 1713 size_t printed = 0;
2ae3a312 1714 struct thread *thread;
77170988 1715 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
bf2575c1 1716 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1717 struct thread_trace *ttrace;
1718
1719 if (sc == NULL)
1720 return -1;
ba3d7dee 1721
2ae3a312
ACM		 1722 if (sc->filtered)
1723 return 0;
1724
8fb598e5 1725 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1726 ttrace = thread__trace(thread, trace->output);
2ae3a312 1727 if (ttrace == NULL)
ba3d7dee
ACM		 1728 return -1;
1729
77170988 1730 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
752fde44
ACM		 1731
1732 if (ttrace->entry_str == NULL) {
1733 ttrace->entry_str = malloc(1024);
1734 if (!ttrace->entry_str)
1735 return -1;
1736 }
1737
13f22a2d 1738 if (!trace->summary_only)
6ebad5c1 1739 trace__printf_interrupted_entry(trace, sample);
e596663e 1740
752fde44
ACM		 1741 ttrace->entry_time = sample->time;
1742 msg = ttrace->entry_str;
1743 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1744
75b757ca
ACM		 1745 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1746 args, trace, thread);
752fde44 1747
5089f20e 1748 if (sc->is_exit) {
fd2eabaf 1749 if (!trace->duration_filter && !trace->summary_only) {
c24ff998
ACM		 1750 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1751 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
ae9ed035 1752 }
752fde44
ACM		 1753 } else
1754 ttrace->entry_pending = true;
ba3d7dee 1755
f3b623b8
ACM		 1756 if (trace->current != thread) {
1757 thread__put(trace->current);
1758 trace->current = thread__get(thread);
1759 }
e596663e 1760
ba3d7dee
ACM		 1761 return 0;
1762}
1763
1764static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1765 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1766 struct perf_sample *sample)
1767{
2c82c3ad 1768 long ret;
60c907ab 1769 u64 duration = 0;
2ae3a312 1770 struct thread *thread;
77170988 1771 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
bf2575c1 1772 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1773 struct thread_trace *ttrace;
1774
1775 if (sc == NULL)
1776 return -1;
ba3d7dee 1777
2ae3a312
ACM		 1778 if (sc->filtered)
1779 return 0;
1780
8fb598e5 1781 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1782 ttrace = thread__trace(thread, trace->output);
2ae3a312 1783 if (ttrace == NULL)
ba3d7dee
ACM		 1784 return -1;
1785
bf2575c1
DA		 1786 if (trace->summary)
1787 thread__update_stats(ttrace, id, sample);
1788
77170988 1789 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
ba3d7dee 1790
c522739d
ACM		 1791 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1792 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1793 trace->last_vfs_getname = NULL;
1794 ++trace->stats.vfs_getname;
1795 }
1796
752fde44
ACM		 1797 ttrace->exit_time = sample->time;
1798
ae9ed035 1799 if (ttrace->entry_time) {
60c907ab 1800 duration = sample->time - ttrace->entry_time;
ae9ed035
ACM		 1801 if (trace__filter_duration(trace, duration))
1802 goto out;
1803 } else if (trace->duration_filter)
1804 goto out;
60c907ab 1805
fd2eabaf
DA		 1806 if (trace->summary_only)
1807 goto out;
1808
c24ff998 1809 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
752fde44
ACM		 1810
1811 if (ttrace->entry_pending) {
c24ff998 1812 fprintf(trace->output, "%-70s", ttrace->entry_str);
752fde44 1813 } else {
c24ff998
ACM		 1814 fprintf(trace->output, " ... [");
1815 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1816 fprintf(trace->output, "]: %s()", sc->name);
752fde44
ACM		 1817 }
1818
da3c9a44
ACM		 1819 if (sc->fmt == NULL) {
1820signed_print:
2c82c3ad 1821 fprintf(trace->output, ") = %ld", ret);
da3c9a44 1822 } else if (ret < 0 && sc->fmt->errmsg) {
942a91ed 1823 char bf[STRERR_BUFSIZE];
ba3d7dee
ACM		 1824 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1825 *e = audit_errno_to_name(-ret);
1826
c24ff998 1827 fprintf(trace->output, ") = -1 %s %s", e, emsg);
da3c9a44 1828 } else if (ret == 0 && sc->fmt->timeout)
c24ff998 1829 fprintf(trace->output, ") = 0 Timeout");
04b34729 1830 else if (sc->fmt->hexret)
2c82c3ad 1831 fprintf(trace->output, ") = %#lx", ret);
ba3d7dee 1832 else
da3c9a44 1833 goto signed_print;
ba3d7dee 1834
c24ff998 1835 fputc('\n', trace->output);
ae9ed035 1836out:
752fde44
ACM		 1837 ttrace->entry_pending = false;
1838
ba3d7dee
ACM		 1839 return 0;
1840}
1841
c522739d 1842static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1843 union perf_event *event __maybe_unused,
c522739d
ACM		 1844 struct perf_sample *sample)
1845{
1846 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1847 return 0;
1848}
1849
1302d88e 1850static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1851 union perf_event *event __maybe_unused,
1302d88e
ACM		 1852 struct perf_sample *sample)
1853{
1854 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1855 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
8fb598e5 1856 struct thread *thread = machine__findnew_thread(trace->host,
314add6b
AH		 1857 sample->pid,
1858 sample->tid);
c24ff998 1859 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1302d88e
ACM		 1860
1861 if (ttrace == NULL)
1862 goto out_dump;
1863
1864 ttrace->runtime_ms += runtime_ms;
1865 trace->runtime_ms += runtime_ms;
1866 return 0;
1867
1868out_dump:
c24ff998 1869 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1302d88e
ACM		 1870 evsel->name,
1871 perf_evsel__strval(evsel, sample, "comm"),
1872 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1873 runtime,
1874 perf_evsel__intval(evsel, sample, "vruntime"));
1875 return 0;
1876}
1877
14a052df
ACM		 1878static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1879 union perf_event *event __maybe_unused,
1880 struct perf_sample *sample)
1881{
1882 trace__printf_interrupted_entry(trace, sample);
1883 trace__fprintf_tstamp(trace, sample->time, trace->output);
0808921a
ACM		 1884
1885 if (trace->trace_syscalls)
1886 fprintf(trace->output, "( ): ");
1887
1888 fprintf(trace->output, "%s:", evsel->name);
14a052df
ACM		 1889
1890 if (evsel->tp_format) {
1891 event_format__fprintf(evsel->tp_format, sample->cpu,
1892 sample->raw_data, sample->raw_size,
1893 trace->output);
1894 }
1895
1896 fprintf(trace->output, ")\n");
1897 return 0;
1898}
1899
598d02c5
SF		 1900static void print_location(FILE *f, struct perf_sample *sample,
1901 struct addr_location *al,
1902 bool print_dso, bool print_sym)
1903{
1904
1905 if ((verbose || print_dso) && al->map)
1906 fprintf(f, "%s@", al->map->dso->long_name);
1907
1908 if ((verbose || print_sym) && al->sym)
4414a3c5 1909 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
598d02c5
SF		 1910 al->addr - al->sym->start);
1911 else if (al->map)
4414a3c5 1912 fprintf(f, "0x%" PRIx64, al->addr);
598d02c5 1913 else
4414a3c5 1914 fprintf(f, "0x%" PRIx64, sample->addr);
598d02c5
SF		 1915}
1916
1917static int trace__pgfault(struct trace *trace,
1918 struct perf_evsel *evsel,
1919 union perf_event *event,
1920 struct perf_sample *sample)
1921{
1922 struct thread *thread;
1923 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1924 struct addr_location al;
1925 char map_type = 'd';
a2ea67d7 1926 struct thread_trace *ttrace;
598d02c5
SF		 1927
1928 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
a2ea67d7
SF		 1929 ttrace = thread__trace(thread, trace->output);
1930 if (ttrace == NULL)
1931 return -1;
1932
1933 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
1934 ttrace->pfmaj++;
1935 else
1936 ttrace->pfmin++;
1937
1938 if (trace->summary_only)
1939 return 0;
598d02c5 1940
bb871a9c 1941 thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
598d02c5
SF		 1942 sample->ip, &al);
1943
1944 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1945
1946 fprintf(trace->output, "%sfault [",
1947 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1948 "maj" : "min");
1949
1950 print_location(trace->output, sample, &al, false, true);
1951
1952 fprintf(trace->output, "] => ");
1953
bb871a9c 1954 thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
598d02c5
SF		 1955 sample->addr, &al);
1956
1957 if (!al.map) {
bb871a9c 1958 thread__find_addr_location(thread, cpumode,
598d02c5
SF		 1959 MAP__FUNCTION, sample->addr, &al);
1960
1961 if (al.map)
1962 map_type = 'x';
1963 else
1964 map_type = '?';
1965 }
1966
1967 print_location(trace->output, sample, &al, true, false);
1968
1969 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1970
1971 return 0;
1972}
1973
bdc89661
DA		 1974static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1975{
1976 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1977 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1978 return false;
1979
1980 if (trace->pid_list || trace->tid_list)
1981 return true;
1982
1983 return false;
1984}
1985
6810fc91 1986static int trace__process_sample(struct perf_tool *tool,
0c82adcf 1987 union perf_event *event,
6810fc91
DA		 1988 struct perf_sample *sample,
1989 struct perf_evsel *evsel,
1990 struct machine *machine __maybe_unused)
1991{
1992 struct trace *trace = container_of(tool, struct trace, tool);
1993 int err = 0;
1994
744a9719 1995 tracepoint_handler handler = evsel->handler;
6810fc91 1996
bdc89661
DA		 1997 if (skip_sample(trace, sample))
1998 return 0;
1999
4bb09192 2000 if (!trace->full_time && trace->base_time == 0)
6810fc91
DA		 2001 trace->base_time = sample->time;
2002
3160565f
DA		 2003 if (handler) {
2004 ++trace->nr_events;
0c82adcf 2005 handler(trace, evsel, event, sample);
3160565f 2006 }
6810fc91
DA		 2007
2008 return err;
2009}
2010
bdc89661
DA		 2011static int parse_target_str(struct trace *trace)
2012{
2013 if (trace->opts.target.pid) {
2014 trace->pid_list = intlist__new(trace->opts.target.pid);
2015 if (trace->pid_list == NULL) {
2016 pr_err("Error parsing process id string\n");
2017 return -EINVAL;
2018 }
2019 }
2020
2021 if (trace->opts.target.tid) {
2022 trace->tid_list = intlist__new(trace->opts.target.tid);
2023 if (trace->tid_list == NULL) {
2024 pr_err("Error parsing thread id string\n");
2025 return -EINVAL;
2026 }
2027 }
2028
2029 return 0;
2030}
2031
1e28fe0a 2032static int trace__record(struct trace *trace, int argc, const char **argv)
5e2485b1
DA		 2033{
2034 unsigned int rec_argc, i, j;
2035 const char **rec_argv;
2036 const char * const record_args[] = {
2037 "record",
2038 "-R",
2039 "-m", "1024",
2040 "-c", "1",
5e2485b1
DA		 2041 };
2042
1e28fe0a
SF		 2043 const char * const sc_args[] = { "-e", };
2044 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2045 const char * const majpf_args[] = { "-e", "major-faults" };
2046 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2047 const char * const minpf_args[] = { "-e", "minor-faults" };
2048 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2049
9aca7f17 2050 /* +1 is for the event string below */
1e28fe0a
SF		 2051 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2052 majpf_args_nr + minpf_args_nr + argc;
5e2485b1
DA		 2053 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2054
2055 if (rec_argv == NULL)
2056 return -ENOMEM;
2057
1e28fe0a 2058 j = 0;
5e2485b1 2059 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1e28fe0a
SF		 2060 rec_argv[j++] = record_args[i];
2061
e281a960
SF		 2062 if (trace->trace_syscalls) {
2063 for (i = 0; i < sc_args_nr; i++)
2064 rec_argv[j++] = sc_args[i];
2065
2066 /* event string may be different for older kernels - e.g., RHEL6 */
2067 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2068 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2069 else if (is_valid_tracepoint("syscalls:sys_enter"))
2070 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2071 else {
2072 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2073 return -1;
2074 }
9aca7f17 2075 }
9aca7f17 2076
1e28fe0a
SF		 2077 if (trace->trace_pgfaults & TRACE_PFMAJ)
2078 for (i = 0; i < majpf_args_nr; i++)
2079 rec_argv[j++] = majpf_args[i];
2080
2081 if (trace->trace_pgfaults & TRACE_PFMIN)
2082 for (i = 0; i < minpf_args_nr; i++)
2083 rec_argv[j++] = minpf_args[i];
2084
2085 for (i = 0; i < (unsigned int)argc; i++)
2086 rec_argv[j++] = argv[i];
5e2485b1 2087
1e28fe0a 2088 return cmd_record(j, rec_argv, NULL);
5e2485b1
DA		 2089}
2090
bf2575c1
DA		 2091static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2092
c522739d
ACM		 2093static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2094{
ef503831 2095 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
c522739d
ACM		 2096 if (evsel == NULL)
2097 return;
2098
2099 if (perf_evsel__field(evsel, "pathname") == NULL) {
2100 perf_evsel__delete(evsel);
2101 return;
2102 }
2103
744a9719 2104 evsel->handler = trace__vfs_getname;
c522739d
ACM		 2105 perf_evlist__add(evlist, evsel);
2106}
2107
598d02c5
SF		 2108static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
2109 u64 config)
2110{
2111 struct perf_evsel *evsel;
2112 struct perf_event_attr attr = {
2113 .type = PERF_TYPE_SOFTWARE,
2114 .mmap_data = 1,
598d02c5
SF		 2115 };
2116
2117 attr.config = config;
0524798c 2118 attr.sample_period = 1;
598d02c5
SF		 2119
2120 event_attr_init(&attr);
2121
2122 evsel = perf_evsel__new(&attr);
2123 if (!evsel)
2124 return -ENOMEM;
2125
2126 evsel->handler = trace__pgfault;
2127 perf_evlist__add(evlist, evsel);
2128
2129 return 0;
2130}
2131
ddbb1b13
ACM		 2132static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2133{
2134 const u32 type = event->header.type;
2135 struct perf_evsel *evsel;
2136
2137 if (!trace->full_time && trace->base_time == 0)
2138 trace->base_time = sample->time;
2139
2140 if (type != PERF_RECORD_SAMPLE) {
2141 trace__process_event(trace, trace->host, event, sample);
2142 return;
2143 }
2144
2145 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2146 if (evsel == NULL) {
2147 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2148 return;
2149 }
2150
2151 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2152 sample->raw_data == NULL) {
2153 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2154 perf_evsel__name(evsel), sample->tid,
2155 sample->cpu, sample->raw_size);
2156 } else {
2157 tracepoint_handler handler = evsel->handler;
2158 handler(trace, evsel, event, sample);
2159 }
2160}
2161
f15eb531 2162static int trace__run(struct trace *trace, int argc, const char **argv)
514f1c67 2163{
14a052df 2164 struct perf_evlist *evlist = trace->evlist;
efd5745e
ACM		 2165 int err = -1, i;
2166 unsigned long before;
f15eb531 2167 const bool forks = argc > 0;
46fb3c21 2168 bool draining = false;
514f1c67 2169
75b757ca
ACM		 2170 trace->live = true;
2171
e281a960
SF		 2172 if (trace->trace_syscalls &&
2173 perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
2174 trace__sys_exit))
801c67b0 2175 goto out_error_raw_syscalls;
514f1c67 2176
e281a960
SF		 2177 if (trace->trace_syscalls)
2178 perf_evlist__add_vfs_getname(evlist);
c522739d 2179
598d02c5 2180 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
e2726d99 2181 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
5ed08dae 2182 goto out_error_mem;
e2726d99 2183 }
598d02c5
SF		 2184
2185 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2186 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
5ed08dae 2187 goto out_error_mem;
598d02c5 2188
1302d88e 2189 if (trace->sched &&
2cc990ba
ACM		 2190 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2191 trace__sched_stat_runtime))
2192 goto out_error_sched_stat_runtime;
1302d88e 2193
514f1c67
ACM		 2194 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2195 if (err < 0) {
c24ff998 2196 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
514f1c67
ACM		 2197 goto out_delete_evlist;
2198 }
2199
752fde44
ACM		 2200 err = trace__symbols_init(trace, evlist);
2201 if (err < 0) {
c24ff998 2202 fprintf(trace->output, "Problems initializing symbol libraries!\n");
03ad9747 2203 goto out_delete_evlist;
752fde44
ACM		 2204 }
2205
f77a9518 2206 perf_evlist__config(evlist, &trace->opts);
514f1c67 2207
f15eb531
NK		 2208 signal(SIGCHLD, sig_handler);
2209 signal(SIGINT, sig_handler);
2210
2211 if (forks) {
6ef73ec4 2212 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
735f7e0b 2213 argv, false, NULL);
f15eb531 2214 if (err < 0) {
c24ff998 2215 fprintf(trace->output, "Couldn't run the workload!\n");
03ad9747 2216 goto out_delete_evlist;
f15eb531
NK		 2217 }
2218 }
2219
514f1c67 2220 err = perf_evlist__open(evlist);
a8f23d8f
ACM		 2221 if (err < 0)
2222 goto out_error_open;
514f1c67 2223
241b057c
ACM		 2224 /*
2225 * Better not use !target__has_task() here because we need to cover the
2226 * case where no threads were specified in the command line, but a
2227 * workload was, and in that case we will fill in the thread_map when
2228 * we fork the workload in perf_evlist__prepare_workload.
2229 */
f078c385
ACM		 2230 if (trace->filter_pids.nr > 0)
2231 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2232 else if (evlist->threads->map[0] == -1)
2233 err = perf_evlist__set_filter_pid(evlist, getpid());
2234
2235 if (err < 0) {
2236 printf("err=%d,%s\n", -err, strerror(-err));
2237 exit(1);
2238 }
241b057c 2239
f885037e 2240 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
e09b18d4
ACM		 2241 if (err < 0)
2242 goto out_error_mmap;
514f1c67 2243
f15eb531
NK		 2244 if (forks)
2245 perf_evlist__start_workload(evlist);
f7aa222f
ACM		 2246 else
2247 perf_evlist__enable(evlist);
f15eb531 2248
42052bea
ACM		 2249 trace->multiple_threads = evlist->threads->map[0] == -1 ||
2250 evlist->threads->nr > 1 ||
2251 perf_evlist__first(evlist)->attr.inherit;
514f1c67 2252again:
efd5745e 2253 before = trace->nr_events;
514f1c67
ACM		 2254
2255 for (i = 0; i < evlist->nr_mmaps; i++) {
2256 union perf_event *event;
2257
2258 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
514f1c67 2259 struct perf_sample sample;
514f1c67 2260
efd5745e 2261 ++trace->nr_events;
514f1c67 2262
514f1c67
ACM		 2263 err = perf_evlist__parse_sample(evlist, event, &sample);
2264 if (err) {
c24ff998 2265 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
8e50d384 2266 goto next_event;
514f1c67
ACM		 2267 }
2268
ddbb1b13 2269 trace__handle_event(trace, event, &sample);
8e50d384
ZZ		 2270next_event:
2271 perf_evlist__mmap_consume(evlist, i);
20c5f10e 2272
ba209f85
ACM		 2273 if (interrupted)
2274 goto out_disable;
514f1c67
ACM		 2275 }
2276 }
2277
efd5745e 2278 if (trace->nr_events == before) {
ba209f85 2279 int timeout = done ? 100 : -1;
f15eb531 2280
46fb3c21
ACM		 2281 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2282 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2283 draining = true;
2284
ba209f85 2285 goto again;
46fb3c21 2286 }
ba209f85
ACM		 2287 } else {
2288 goto again;
f15eb531
NK		 2289 }
2290
ba209f85 2291out_disable:
f3b623b8
ACM		 2292 thread__zput(trace->current);
2293
ba209f85 2294 perf_evlist__disable(evlist);
514f1c67 2295
c522739d
ACM		 2296 if (!err) {
2297 if (trace->summary)
2298 trace__fprintf_thread_summary(trace, trace->output);
2299
2300 if (trace->show_tool_stats) {
2301 fprintf(trace->output, "Stats:\n "
2302 " vfs_getname : %" PRIu64 "\n"
2303 " proc_getname: %" PRIu64 "\n",
2304 trace->stats.vfs_getname,
2305 trace->stats.proc_getname);
2306 }
2307 }
bf2575c1 2308
514f1c67
ACM		 2309out_delete_evlist:
2310 perf_evlist__delete(evlist);
14a052df 2311 trace->evlist = NULL;
75b757ca 2312 trace->live = false;
514f1c67 2313 return err;
6ef068cb
ACM		 2314{
2315 char errbuf[BUFSIZ];
a8f23d8f 2316
2cc990ba
ACM		 2317out_error_sched_stat_runtime:
2318 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2319 goto out_error;
2320
801c67b0 2321out_error_raw_syscalls:
2cc990ba 2322 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
a8f23d8f
ACM		 2323 goto out_error;
2324
e09b18d4
ACM		 2325out_error_mmap:
2326 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2327 goto out_error;
2328
a8f23d8f
ACM		 2329out_error_open:
2330 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2331
2332out_error:
6ef068cb 2333 fprintf(trace->output, "%s\n", errbuf);
87f91868 2334 goto out_delete_evlist;
514f1c67 2335}
5ed08dae
ACM		 2336out_error_mem:
2337 fprintf(trace->output, "Not enough memory to run!\n");
2338 goto out_delete_evlist;
a8f23d8f 2339}
514f1c67 2340
6810fc91
DA		 2341static int trace__replay(struct trace *trace)
2342{
2343 const struct perf_evsel_str_handler handlers[] = {
c522739d 2344 { "probe:vfs_getname", trace__vfs_getname, },
6810fc91 2345 };
f5fc1412
JO		 2346 struct perf_data_file file = {
2347 .path = input_name,
2348 .mode = PERF_DATA_MODE_READ,
e366a6d8 2349 .force = trace->force,
f5fc1412 2350 };
6810fc91 2351 struct perf_session *session;
003824e8 2352 struct perf_evsel *evsel;
6810fc91
DA		 2353 int err = -1;
2354
2355 trace->tool.sample = trace__process_sample;
2356 trace->tool.mmap = perf_event__process_mmap;
384c671e 2357 trace->tool.mmap2 = perf_event__process_mmap2;
6810fc91
DA		 2358 trace->tool.comm = perf_event__process_comm;
2359 trace->tool.exit = perf_event__process_exit;
2360 trace->tool.fork = perf_event__process_fork;
2361 trace->tool.attr = perf_event__process_attr;
2362 trace->tool.tracing_data = perf_event__process_tracing_data;
2363 trace->tool.build_id = perf_event__process_build_id;
2364
0a8cb85c 2365 trace->tool.ordered_events = true;
6810fc91
DA		 2366 trace->tool.ordering_requires_timestamps = true;
2367
2368 /* add tid to output */
2369 trace->multiple_threads = true;
2370
f5fc1412 2371 session = perf_session__new(&file, false, &trace->tool);
6810fc91 2372 if (session == NULL)
52e02834 2373 return -1;
6810fc91 2374
0a7e6d1b 2375 if (symbol__init(&session->header.env) < 0)
cb2ffae2
NK		 2376 goto out;
2377
8fb598e5
DA		 2378 trace->host = &session->machines.host;
2379
6810fc91
DA		 2380 err = perf_session__set_tracepoints_handlers(session, handlers);
2381 if (err)
2382 goto out;
2383
003824e8
NK		 2384 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2385 "raw_syscalls:sys_enter");
9aca7f17
DA		 2386 /* older kernels have syscalls tp versus raw_syscalls */
2387 if (evsel == NULL)
2388 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2389 "syscalls:sys_enter");
003824e8 2390
e281a960
SF		 2391 if (evsel &&
2392 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2393 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
003824e8
NK		 2394 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2395 goto out;
2396 }
2397
2398 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2399 "raw_syscalls:sys_exit");
9aca7f17
DA		 2400 if (evsel == NULL)
2401 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2402 "syscalls:sys_exit");
e281a960
SF		 2403 if (evsel &&
2404 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2405 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
003824e8 2406 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
6810fc91
DA		 2407 goto out;
2408 }
2409
1e28fe0a
SF		 2410 evlist__for_each(session->evlist, evsel) {
2411 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2412 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2413 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2414 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2415 evsel->handler = trace__pgfault;
2416 }
2417
bdc89661
DA		 2418 err = parse_target_str(trace);
2419 if (err != 0)
2420 goto out;
2421
6810fc91
DA		 2422 setup_pager();
2423
b7b61cbe 2424 err = perf_session__process_events(session);
6810fc91
DA		 2425 if (err)
2426 pr_err("Failed to process events, error %d", err);
2427
bf2575c1
DA		 2428 else if (trace->summary)
2429 trace__fprintf_thread_summary(trace, trace->output);
2430
6810fc91
DA		 2431out:
2432 perf_session__delete(session);
2433
2434 return err;
2435}
2436
1302d88e
ACM		 2437static size_t trace__fprintf_threads_header(FILE *fp)
2438{
2439 size_t printed;
2440
99ff7150 2441 printed = fprintf(fp, "\n Summary of events:\n\n");
bf2575c1
DA		 2442
2443 return printed;
2444}
2445
2446static size_t thread__dump_stats(struct thread_trace *ttrace,
2447 struct trace *trace, FILE *fp)
2448{
2449 struct stats *stats;
2450 size_t printed = 0;
2451 struct syscall *sc;
2452 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2453
2454 if (inode == NULL)
2455 return 0;
2456
2457 printed += fprintf(fp, "\n");
2458
27a778b5
PE		 2459 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2460 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2461 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
99ff7150 2462
bf2575c1
DA		 2463 /* each int_node is a syscall */
2464 while (inode) {
2465 stats = inode->priv;
2466 if (stats) {
2467 double min = (double)(stats->min) / NSEC_PER_MSEC;
2468 double max = (double)(stats->max) / NSEC_PER_MSEC;
2469 double avg = avg_stats(stats);
2470 double pct;
2471 u64 n = (u64) stats->n;
2472
2473 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2474 avg /= NSEC_PER_MSEC;
2475
2476 sc = &trace->syscalls.table[inode->i];
99ff7150 2477 printed += fprintf(fp, " %-15s", sc->name);
27a778b5 2478 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
7f7a4138 2479 n, min, avg);
27a778b5 2480 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
bf2575c1
DA		 2481 }
2482
2483 inode = intlist__next(inode);
2484 }
2485
2486 printed += fprintf(fp, "\n\n");
1302d88e
ACM		 2487
2488 return printed;
2489}
2490
896cbb56
DA		 2491/* struct used to pass data to per-thread function */
2492struct summary_data {
2493 FILE *fp;
2494 struct trace *trace;
2495 size_t printed;
2496};
2497
2498static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2499{
2500 struct summary_data *data = priv;
2501 FILE *fp = data->fp;
2502 size_t printed = data->printed;
2503 struct trace *trace = data->trace;
89dceb22 2504 struct thread_trace *ttrace = thread__priv(thread);
896cbb56
DA		 2505 double ratio;
2506
2507 if (ttrace == NULL)
2508 return 0;
2509
2510 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2511
15e65c69 2512 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
99ff7150 2513 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
15e65c69 2514 printed += fprintf(fp, "%.1f%%", ratio);
a2ea67d7
SF		 2515 if (ttrace->pfmaj)
2516 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2517 if (ttrace->pfmin)
2518 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
99ff7150 2519 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
bf2575c1 2520 printed += thread__dump_stats(ttrace, trace, fp);
896cbb56
DA		 2521
2522 data->printed += printed;
2523
2524 return 0;
2525}
2526
1302d88e
ACM		 2527static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2528{
896cbb56
DA		 2529 struct summary_data data = {
2530 .fp = fp,
2531 .trace = trace
2532 };
2533 data.printed = trace__fprintf_threads_header(fp);
1302d88e 2534
896cbb56
DA		 2535 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2536
2537 return data.printed;
1302d88e
ACM		 2538}
2539
ae9ed035
ACM		 2540static int trace__set_duration(const struct option *opt, const char *str,
2541 int unset __maybe_unused)
2542{
2543 struct trace *trace = opt->value;
2544
2545 trace->duration_filter = atof(str);
2546 return 0;
2547}
2548
f078c385
ACM		 2549static int trace__set_filter_pids(const struct option *opt, const char *str,
2550 int unset __maybe_unused)
2551{
2552 int ret = -1;
2553 size_t i;
2554 struct trace *trace = opt->value;
2555 /*
2556 * FIXME: introduce a intarray class, plain parse csv and create a
2557 * { int nr, int entries[] } struct...
2558 */
2559 struct intlist *list = intlist__new(str);
2560
2561 if (list == NULL)
2562 return -1;
2563
2564 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2565 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2566
2567 if (trace->filter_pids.entries == NULL)
2568 goto out;
2569
2570 trace->filter_pids.entries[0] = getpid();
2571
2572 for (i = 1; i < trace->filter_pids.nr; ++i)
2573 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2574
2575 intlist__delete(list);
2576 ret = 0;
2577out:
2578 return ret;
2579}
2580
c24ff998
ACM		 2581static int trace__open_output(struct trace *trace, const char *filename)
2582{
2583 struct stat st;
2584
2585 if (!stat(filename, &st) && st.st_size) {
2586 char oldname[PATH_MAX];
2587
2588 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2589 unlink(oldname);
2590 rename(filename, oldname);
2591 }
2592
2593 trace->output = fopen(filename, "w");
2594
2595 return trace->output == NULL ? -errno : 0;
2596}
2597
598d02c5
SF		 2598static int parse_pagefaults(const struct option *opt, const char *str,
2599 int unset __maybe_unused)
2600{
2601 int *trace_pgfaults = opt->value;
2602
2603 if (strcmp(str, "all") == 0)
2604 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2605 else if (strcmp(str, "maj") == 0)
2606 *trace_pgfaults |= TRACE_PFMAJ;
2607 else if (strcmp(str, "min") == 0)
2608 *trace_pgfaults |= TRACE_PFMIN;
2609 else
2610 return -1;
2611
2612 return 0;
2613}
2614
14a052df
ACM		 2615static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2616{
2617 struct perf_evsel *evsel;
2618
2619 evlist__for_each(evlist, evsel)
2620 evsel->handler = handler;
2621}
2622
514f1c67
ACM		 2623int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2624{
6fdd9cb7 2625 const char *trace_usage[] = {
f15eb531
NK		 2626 "perf trace [<options>] [<command>]",
2627 "perf trace [<options>] -- <command> [<options>]",
5e2485b1
DA		 2628 "perf trace record [<options>] [<command>]",
2629 "perf trace record [<options>] -- <command> [<options>]",
514f1c67
ACM		 2630 NULL
2631 };
2632 struct trace trace = {
c522739d
ACM		 2633 .audit = {
2634 .machine = audit_detect_machine(),
2635 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2636 },
514f1c67
ACM		 2637 .syscalls = {
2638 . max = -1,
2639 },
2640 .opts = {
2641 .target = {
2642 .uid = UINT_MAX,
2643 .uses_mmap = true,
2644 },
2645 .user_freq = UINT_MAX,
2646 .user_interval = ULLONG_MAX,
509051ea 2647 .no_buffering = true,
38d5447d 2648 .mmap_pages = UINT_MAX,
514f1c67 2649 },
c24ff998 2650 .output = stdout,
50c95cbd 2651 .show_comm = true,
e281a960 2652 .trace_syscalls = true,
514f1c67 2653 };
c24ff998 2654 const char *output_name = NULL;
2ae3a312 2655 const char *ev_qualifier_str = NULL;
514f1c67 2656 const struct option trace_options[] = {
14a052df
ACM		 2657 OPT_CALLBACK(0, "event", &trace.evlist, "event",
2658 "event selector. use 'perf list' to list available events",
2659 parse_events_option),
50c95cbd
ACM		 2660 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2661 "show the thread COMM next to its id"),
c522739d 2662 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2ae3a312
ACM		 2663 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2664 "list of events to trace"),
c24ff998 2665 OPT_STRING('o', "output", &output_name, "file", "output file name"),
6810fc91 2666 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
514f1c67
ACM		 2667 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2668 "trace events on existing process id"),
ac9be8ee 2669 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
514f1c67 2670 "trace events on existing thread id"),
f078c385
ACM		 2671 OPT_CALLBACK(0, "filter-pids", &trace, "float",
2672 "show only events with duration > N.M ms", trace__set_filter_pids),
ac9be8ee 2673 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
514f1c67 2674 "system-wide collection from all CPUs"),
ac9be8ee 2675 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
514f1c67 2676 "list of cpus to monitor"),
6810fc91 2677 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
514f1c67 2678 "child tasks do not inherit counters"),
994a1f78
JO		 2679 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2680 "number of mmap data pages",
2681 perf_evlist__parse_mmap_pages),
ac9be8ee 2682 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
514f1c67 2683 "user to profile"),
ae9ed035
ACM		 2684 OPT_CALLBACK(0, "duration", &trace, "float",
2685 "show only events with duration > N.M ms",
2686 trace__set_duration),
1302d88e 2687 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
7c304ee0 2688 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
4bb09192
DA		 2689 OPT_BOOLEAN('T', "time", &trace.full_time,
2690 "Show full timestamp, not time relative to first start"),
fd2eabaf
DA		 2691 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2692 "Show only syscall summary with statistics"),
2693 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2694 "Show all syscalls and summary with statistics"),
598d02c5
SF		 2695 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2696 "Trace pagefaults", parse_pagefaults, "maj"),
e281a960 2697 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
e366a6d8 2698 OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
514f1c67
ACM		 2699 OPT_END()
2700 };
6fdd9cb7 2701 const char * const trace_subcommands[] = { "record", NULL };
514f1c67 2702 int err;
32caf0d1 2703 char bf[BUFSIZ];
514f1c67 2704
4d08cb80
ACM		 2705 signal(SIGSEGV, sighandler_dump_stack);
2706 signal(SIGFPE, sighandler_dump_stack);
2707
14a052df
ACM		 2708 trace.evlist = perf_evlist__new();
2709 if (trace.evlist == NULL)
2710 return -ENOMEM;
2711
2712 if (trace.evlist == NULL) {
2713 pr_err("Not enough memory to run!\n");
2714 goto out;
2715 }
2716
6fdd9cb7
YS		 2717 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
2718 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
fd2eabaf 2719
598d02c5
SF		 2720 if (trace.trace_pgfaults) {
2721 trace.opts.sample_address = true;
2722 trace.opts.sample_time = true;
2723 }
2724
14a052df
ACM		 2725 if (trace.evlist->nr_entries > 0)
2726 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
2727
1e28fe0a
SF		 2728 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2729 return trace__record(&trace, argc-1, &argv[1]);
2730
2731 /* summary_only implies summary option, but don't overwrite summary if set */
2732 if (trace.summary_only)
2733 trace.summary = trace.summary_only;
2734
726f3234
ACM		 2735 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
2736 trace.evlist->nr_entries == 0 /* Was --events used? */) {
e281a960
SF		 2737 pr_err("Please specify something to trace.\n");
2738 return -1;
2739 }
2740
c24ff998
ACM		 2741 if (output_name != NULL) {
2742 err = trace__open_output(&trace, output_name);
2743 if (err < 0) {
2744 perror("failed to create output file");
2745 goto out;
2746 }
2747 }
2748
2ae3a312 2749 if (ev_qualifier_str != NULL) {
b059efdf
ACM		 2750 const char *s = ev_qualifier_str;
2751
2752 trace.not_ev_qualifier = *s == '!';
2753 if (trace.not_ev_qualifier)
2754 ++s;
2755 trace.ev_qualifier = strlist__new(true, s);
2ae3a312 2756 if (trace.ev_qualifier == NULL) {
c24ff998
ACM		 2757 fputs("Not enough memory to parse event qualifier",
2758 trace.output);
2759 err = -ENOMEM;
2760 goto out_close;
2ae3a312
ACM		 2761 }
2762 }
2763
602ad878 2764 err = target__validate(&trace.opts.target);
32caf0d1 2765 if (err) {
602ad878 2766 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2767 fprintf(trace.output, "%s", bf);
2768 goto out_close;
32caf0d1
NK		 2769 }
2770
602ad878 2771 err = target__parse_uid(&trace.opts.target);
514f1c67 2772 if (err) {
602ad878 2773 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2774 fprintf(trace.output, "%s", bf);
2775 goto out_close;
514f1c67
ACM		 2776 }
2777
602ad878 2778 if (!argc && target__none(&trace.opts.target))
ee76120e
NK		 2779 trace.opts.target.system_wide = true;
2780
6810fc91
DA		 2781 if (input_name)
2782 err = trace__replay(&trace);
2783 else
2784 err = trace__run(&trace, argc, argv);
1302d88e 2785
c24ff998
ACM		 2786out_close:
2787 if (output_name != NULL)
2788 fclose(trace.output);
2789out:
1302d88e 2790 return err;
514f1c67 2791}