]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - tools/perf/builtin-trace.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf trace: Enable events when doing system wide tracing and starting a workload
[mirror_ubuntu-bionic-kernel.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
cb24d01d
ACM		 2244 if (!target__none(&trace->opts.target))
2245 perf_evlist__enable(evlist);
2246
f15eb531
NK		 2247 if (forks)
2248 perf_evlist__start_workload(evlist);
2249
42052bea
ACM		 2250 trace->multiple_threads = evlist->threads->map[0] == -1 ||
2251 evlist->threads->nr > 1 ||
2252 perf_evlist__first(evlist)->attr.inherit;
514f1c67 2253again:
efd5745e 2254 before = trace->nr_events;
514f1c67
ACM		 2255
2256 for (i = 0; i < evlist->nr_mmaps; i++) {
2257 union perf_event *event;
2258
2259 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
514f1c67 2260 struct perf_sample sample;
514f1c67 2261
efd5745e 2262 ++trace->nr_events;
514f1c67 2263
514f1c67
ACM		 2264 err = perf_evlist__parse_sample(evlist, event, &sample);
2265 if (err) {
c24ff998 2266 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
8e50d384 2267 goto next_event;
514f1c67
ACM		 2268 }
2269
ddbb1b13 2270 trace__handle_event(trace, event, &sample);
8e50d384
ZZ		 2271next_event:
2272 perf_evlist__mmap_consume(evlist, i);
20c5f10e 2273
ba209f85
ACM		 2274 if (interrupted)
2275 goto out_disable;
514f1c67
ACM		 2276 }
2277 }
2278
efd5745e 2279 if (trace->nr_events == before) {
ba209f85 2280 int timeout = done ? 100 : -1;
f15eb531 2281
46fb3c21
ACM		 2282 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2283 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2284 draining = true;
2285
ba209f85 2286 goto again;
46fb3c21 2287 }
ba209f85
ACM		 2288 } else {
2289 goto again;
f15eb531
NK		 2290 }
2291
ba209f85 2292out_disable:
f3b623b8
ACM		 2293 thread__zput(trace->current);
2294
ba209f85 2295 perf_evlist__disable(evlist);
514f1c67 2296
c522739d
ACM		 2297 if (!err) {
2298 if (trace->summary)
2299 trace__fprintf_thread_summary(trace, trace->output);
2300
2301 if (trace->show_tool_stats) {
2302 fprintf(trace->output, "Stats:\n "
2303 " vfs_getname : %" PRIu64 "\n"
2304 " proc_getname: %" PRIu64 "\n",
2305 trace->stats.vfs_getname,
2306 trace->stats.proc_getname);
2307 }
2308 }
bf2575c1 2309
514f1c67
ACM		 2310out_delete_evlist:
2311 perf_evlist__delete(evlist);
14a052df 2312 trace->evlist = NULL;
75b757ca 2313 trace->live = false;
514f1c67 2314 return err;
6ef068cb
ACM		 2315{
2316 char errbuf[BUFSIZ];
a8f23d8f 2317
2cc990ba
ACM		 2318out_error_sched_stat_runtime:
2319 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2320 goto out_error;
2321
801c67b0 2322out_error_raw_syscalls:
2cc990ba 2323 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
a8f23d8f
ACM		 2324 goto out_error;
2325
e09b18d4
ACM		 2326out_error_mmap:
2327 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2328 goto out_error;
2329
a8f23d8f
ACM		 2330out_error_open:
2331 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2332
2333out_error:
6ef068cb 2334 fprintf(trace->output, "%s\n", errbuf);
87f91868 2335 goto out_delete_evlist;
514f1c67 2336}
5ed08dae
ACM		 2337out_error_mem:
2338 fprintf(trace->output, "Not enough memory to run!\n");
2339 goto out_delete_evlist;
a8f23d8f 2340}
514f1c67 2341
6810fc91
DA		 2342static int trace__replay(struct trace *trace)
2343{
2344 const struct perf_evsel_str_handler handlers[] = {
c522739d 2345 { "probe:vfs_getname", trace__vfs_getname, },
6810fc91 2346 };
f5fc1412
JO		 2347 struct perf_data_file file = {
2348 .path = input_name,
2349 .mode = PERF_DATA_MODE_READ,
e366a6d8 2350 .force = trace->force,
f5fc1412 2351 };
6810fc91 2352 struct perf_session *session;
003824e8 2353 struct perf_evsel *evsel;
6810fc91
DA		 2354 int err = -1;
2355
2356 trace->tool.sample = trace__process_sample;
2357 trace->tool.mmap = perf_event__process_mmap;
384c671e 2358 trace->tool.mmap2 = perf_event__process_mmap2;
6810fc91
DA		 2359 trace->tool.comm = perf_event__process_comm;
2360 trace->tool.exit = perf_event__process_exit;
2361 trace->tool.fork = perf_event__process_fork;
2362 trace->tool.attr = perf_event__process_attr;
2363 trace->tool.tracing_data = perf_event__process_tracing_data;
2364 trace->tool.build_id = perf_event__process_build_id;
2365
0a8cb85c 2366 trace->tool.ordered_events = true;
6810fc91
DA		 2367 trace->tool.ordering_requires_timestamps = true;
2368
2369 /* add tid to output */
2370 trace->multiple_threads = true;
2371
f5fc1412 2372 session = perf_session__new(&file, false, &trace->tool);
6810fc91 2373 if (session == NULL)
52e02834 2374 return -1;
6810fc91 2375
0a7e6d1b 2376 if (symbol__init(&session->header.env) < 0)
cb2ffae2
NK		 2377 goto out;
2378
8fb598e5
DA		 2379 trace->host = &session->machines.host;
2380
6810fc91
DA		 2381 err = perf_session__set_tracepoints_handlers(session, handlers);
2382 if (err)
2383 goto out;
2384
003824e8
NK		 2385 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2386 "raw_syscalls:sys_enter");
9aca7f17
DA		 2387 /* older kernels have syscalls tp versus raw_syscalls */
2388 if (evsel == NULL)
2389 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2390 "syscalls:sys_enter");
003824e8 2391
e281a960
SF		 2392 if (evsel &&
2393 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2394 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
003824e8
NK		 2395 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2396 goto out;
2397 }
2398
2399 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2400 "raw_syscalls:sys_exit");
9aca7f17
DA		 2401 if (evsel == NULL)
2402 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2403 "syscalls:sys_exit");
e281a960
SF		 2404 if (evsel &&
2405 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2406 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
003824e8 2407 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
6810fc91
DA		 2408 goto out;
2409 }
2410
1e28fe0a
SF		 2411 evlist__for_each(session->evlist, evsel) {
2412 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2413 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2414 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2415 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2416 evsel->handler = trace__pgfault;
2417 }
2418
bdc89661
DA		 2419 err = parse_target_str(trace);
2420 if (err != 0)
2421 goto out;
2422
6810fc91
DA		 2423 setup_pager();
2424
b7b61cbe 2425 err = perf_session__process_events(session);
6810fc91
DA		 2426 if (err)
2427 pr_err("Failed to process events, error %d", err);
2428
bf2575c1
DA		 2429 else if (trace->summary)
2430 trace__fprintf_thread_summary(trace, trace->output);
2431
6810fc91
DA		 2432out:
2433 perf_session__delete(session);
2434
2435 return err;
2436}
2437
1302d88e
ACM		 2438static size_t trace__fprintf_threads_header(FILE *fp)
2439{
2440 size_t printed;
2441
99ff7150 2442 printed = fprintf(fp, "\n Summary of events:\n\n");
bf2575c1
DA		 2443
2444 return printed;
2445}
2446
2447static size_t thread__dump_stats(struct thread_trace *ttrace,
2448 struct trace *trace, FILE *fp)
2449{
2450 struct stats *stats;
2451 size_t printed = 0;
2452 struct syscall *sc;
2453 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2454
2455 if (inode == NULL)
2456 return 0;
2457
2458 printed += fprintf(fp, "\n");
2459
27a778b5
PE		 2460 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2461 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2462 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
99ff7150 2463
bf2575c1
DA		 2464 /* each int_node is a syscall */
2465 while (inode) {
2466 stats = inode->priv;
2467 if (stats) {
2468 double min = (double)(stats->min) / NSEC_PER_MSEC;
2469 double max = (double)(stats->max) / NSEC_PER_MSEC;
2470 double avg = avg_stats(stats);
2471 double pct;
2472 u64 n = (u64) stats->n;
2473
2474 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2475 avg /= NSEC_PER_MSEC;
2476
2477 sc = &trace->syscalls.table[inode->i];
99ff7150 2478 printed += fprintf(fp, " %-15s", sc->name);
27a778b5 2479 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
7f7a4138 2480 n, min, avg);
27a778b5 2481 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
bf2575c1
DA		 2482 }
2483
2484 inode = intlist__next(inode);
2485 }
2486
2487 printed += fprintf(fp, "\n\n");
1302d88e
ACM		 2488
2489 return printed;
2490}
2491
896cbb56
DA		 2492/* struct used to pass data to per-thread function */
2493struct summary_data {
2494 FILE *fp;
2495 struct trace *trace;
2496 size_t printed;
2497};
2498
2499static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2500{
2501 struct summary_data *data = priv;
2502 FILE *fp = data->fp;
2503 size_t printed = data->printed;
2504 struct trace *trace = data->trace;
89dceb22 2505 struct thread_trace *ttrace = thread__priv(thread);
896cbb56
DA		 2506 double ratio;
2507
2508 if (ttrace == NULL)
2509 return 0;
2510
2511 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2512
15e65c69 2513 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
99ff7150 2514 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
15e65c69 2515 printed += fprintf(fp, "%.1f%%", ratio);
a2ea67d7
SF		 2516 if (ttrace->pfmaj)
2517 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2518 if (ttrace->pfmin)
2519 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
99ff7150 2520 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
bf2575c1 2521 printed += thread__dump_stats(ttrace, trace, fp);
896cbb56
DA		 2522
2523 data->printed += printed;
2524
2525 return 0;
2526}
2527
1302d88e
ACM		 2528static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2529{
896cbb56
DA		 2530 struct summary_data data = {
2531 .fp = fp,
2532 .trace = trace
2533 };
2534 data.printed = trace__fprintf_threads_header(fp);
1302d88e 2535
896cbb56
DA		 2536 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2537
2538 return data.printed;
1302d88e
ACM		 2539}
2540
ae9ed035
ACM		 2541static int trace__set_duration(const struct option *opt, const char *str,
2542 int unset __maybe_unused)
2543{
2544 struct trace *trace = opt->value;
2545
2546 trace->duration_filter = atof(str);
2547 return 0;
2548}
2549
f078c385
ACM		 2550static int trace__set_filter_pids(const struct option *opt, const char *str,
2551 int unset __maybe_unused)
2552{
2553 int ret = -1;
2554 size_t i;
2555 struct trace *trace = opt->value;
2556 /*
2557 * FIXME: introduce a intarray class, plain parse csv and create a
2558 * { int nr, int entries[] } struct...
2559 */
2560 struct intlist *list = intlist__new(str);
2561
2562 if (list == NULL)
2563 return -1;
2564
2565 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2566 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2567
2568 if (trace->filter_pids.entries == NULL)
2569 goto out;
2570
2571 trace->filter_pids.entries[0] = getpid();
2572
2573 for (i = 1; i < trace->filter_pids.nr; ++i)
2574 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2575
2576 intlist__delete(list);
2577 ret = 0;
2578out:
2579 return ret;
2580}
2581
c24ff998
ACM		 2582static int trace__open_output(struct trace *trace, const char *filename)
2583{
2584 struct stat st;
2585
2586 if (!stat(filename, &st) && st.st_size) {
2587 char oldname[PATH_MAX];
2588
2589 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2590 unlink(oldname);
2591 rename(filename, oldname);
2592 }
2593
2594 trace->output = fopen(filename, "w");
2595
2596 return trace->output == NULL ? -errno : 0;
2597}
2598
598d02c5
SF		 2599static int parse_pagefaults(const struct option *opt, const char *str,
2600 int unset __maybe_unused)
2601{
2602 int *trace_pgfaults = opt->value;
2603
2604 if (strcmp(str, "all") == 0)
2605 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2606 else if (strcmp(str, "maj") == 0)
2607 *trace_pgfaults |= TRACE_PFMAJ;
2608 else if (strcmp(str, "min") == 0)
2609 *trace_pgfaults |= TRACE_PFMIN;
2610 else
2611 return -1;
2612
2613 return 0;
2614}
2615
14a052df
ACM		 2616static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2617{
2618 struct perf_evsel *evsel;
2619
2620 evlist__for_each(evlist, evsel)
2621 evsel->handler = handler;
2622}
2623
514f1c67
ACM		 2624int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2625{
6fdd9cb7 2626 const char *trace_usage[] = {
f15eb531
NK		 2627 "perf trace [<options>] [<command>]",
2628 "perf trace [<options>] -- <command> [<options>]",
5e2485b1
DA		 2629 "perf trace record [<options>] [<command>]",
2630 "perf trace record [<options>] -- <command> [<options>]",
514f1c67
ACM		 2631 NULL
2632 };
2633 struct trace trace = {
c522739d
ACM		 2634 .audit = {
2635 .machine = audit_detect_machine(),
2636 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2637 },
514f1c67
ACM		 2638 .syscalls = {
2639 . max = -1,
2640 },
2641 .opts = {
2642 .target = {
2643 .uid = UINT_MAX,
2644 .uses_mmap = true,
2645 },
2646 .user_freq = UINT_MAX,
2647 .user_interval = ULLONG_MAX,
509051ea 2648 .no_buffering = true,
38d5447d 2649 .mmap_pages = UINT_MAX,
514f1c67 2650 },
c24ff998 2651 .output = stdout,
50c95cbd 2652 .show_comm = true,
e281a960 2653 .trace_syscalls = true,
514f1c67 2654 };
c24ff998 2655 const char *output_name = NULL;
2ae3a312 2656 const char *ev_qualifier_str = NULL;
514f1c67 2657 const struct option trace_options[] = {
14a052df
ACM		 2658 OPT_CALLBACK(0, "event", &trace.evlist, "event",
2659 "event selector. use 'perf list' to list available events",
2660 parse_events_option),
50c95cbd
ACM		 2661 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2662 "show the thread COMM next to its id"),
c522739d 2663 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2ae3a312
ACM		 2664 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2665 "list of events to trace"),
c24ff998 2666 OPT_STRING('o', "output", &output_name, "file", "output file name"),
6810fc91 2667 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
514f1c67
ACM		 2668 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2669 "trace events on existing process id"),
ac9be8ee 2670 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
514f1c67 2671 "trace events on existing thread id"),
f078c385
ACM		 2672 OPT_CALLBACK(0, "filter-pids", &trace, "float",
2673 "show only events with duration > N.M ms", trace__set_filter_pids),
ac9be8ee 2674 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
514f1c67 2675 "system-wide collection from all CPUs"),
ac9be8ee 2676 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
514f1c67 2677 "list of cpus to monitor"),
6810fc91 2678 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
514f1c67 2679 "child tasks do not inherit counters"),
994a1f78
JO		 2680 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2681 "number of mmap data pages",
2682 perf_evlist__parse_mmap_pages),
ac9be8ee 2683 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
514f1c67 2684 "user to profile"),
ae9ed035
ACM		 2685 OPT_CALLBACK(0, "duration", &trace, "float",
2686 "show only events with duration > N.M ms",
2687 trace__set_duration),
1302d88e 2688 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
7c304ee0 2689 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
4bb09192
DA		 2690 OPT_BOOLEAN('T', "time", &trace.full_time,
2691 "Show full timestamp, not time relative to first start"),
fd2eabaf
DA		 2692 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2693 "Show only syscall summary with statistics"),
2694 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2695 "Show all syscalls and summary with statistics"),
598d02c5
SF		 2696 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2697 "Trace pagefaults", parse_pagefaults, "maj"),
e281a960 2698 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
e366a6d8 2699 OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
514f1c67
ACM		 2700 OPT_END()
2701 };
6fdd9cb7 2702 const char * const trace_subcommands[] = { "record", NULL };
514f1c67 2703 int err;
32caf0d1 2704 char bf[BUFSIZ];
514f1c67 2705
4d08cb80
ACM		 2706 signal(SIGSEGV, sighandler_dump_stack);
2707 signal(SIGFPE, sighandler_dump_stack);
2708
14a052df
ACM		 2709 trace.evlist = perf_evlist__new();
2710 if (trace.evlist == NULL)
2711 return -ENOMEM;
2712
2713 if (trace.evlist == NULL) {
2714 pr_err("Not enough memory to run!\n");
2715 goto out;
2716 }
2717
6fdd9cb7
YS		 2718 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
2719 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
fd2eabaf 2720
598d02c5
SF		 2721 if (trace.trace_pgfaults) {
2722 trace.opts.sample_address = true;
2723 trace.opts.sample_time = true;
2724 }
2725
14a052df
ACM		 2726 if (trace.evlist->nr_entries > 0)
2727 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
2728
1e28fe0a
SF		 2729 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2730 return trace__record(&trace, argc-1, &argv[1]);
2731
2732 /* summary_only implies summary option, but don't overwrite summary if set */
2733 if (trace.summary_only)
2734 trace.summary = trace.summary_only;
2735
726f3234
ACM		 2736 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
2737 trace.evlist->nr_entries == 0 /* Was --events used? */) {
e281a960
SF		 2738 pr_err("Please specify something to trace.\n");
2739 return -1;
2740 }
2741
c24ff998
ACM		 2742 if (output_name != NULL) {
2743 err = trace__open_output(&trace, output_name);
2744 if (err < 0) {
2745 perror("failed to create output file");
2746 goto out;
2747 }
2748 }
2749
2ae3a312 2750 if (ev_qualifier_str != NULL) {
b059efdf
ACM		 2751 const char *s = ev_qualifier_str;
2752
2753 trace.not_ev_qualifier = *s == '!';
2754 if (trace.not_ev_qualifier)
2755 ++s;
2756 trace.ev_qualifier = strlist__new(true, s);
2ae3a312 2757 if (trace.ev_qualifier == NULL) {
c24ff998
ACM		 2758 fputs("Not enough memory to parse event qualifier",
2759 trace.output);
2760 err = -ENOMEM;
2761 goto out_close;
2ae3a312
ACM		 2762 }
2763 }
2764
602ad878 2765 err = target__validate(&trace.opts.target);
32caf0d1 2766 if (err) {
602ad878 2767 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2768 fprintf(trace.output, "%s", bf);
2769 goto out_close;
32caf0d1
NK		 2770 }
2771
602ad878 2772 err = target__parse_uid(&trace.opts.target);
514f1c67 2773 if (err) {
602ad878 2774 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2775 fprintf(trace.output, "%s", bf);
2776 goto out_close;
514f1c67
ACM		 2777 }
2778
602ad878 2779 if (!argc && target__none(&trace.opts.target))
ee76120e
NK		 2780 trace.opts.target.system_wide = true;
2781
6810fc91
DA		 2782 if (input_name)
2783 err = trace__replay(&trace);
2784 else
2785 err = trace__run(&trace, argc, argv);
1302d88e 2786
c24ff998
ACM		 2787out_close:
2788 if (output_name != NULL)
2789 fclose(trace.output);
2790out:
1302d88e 2791 return err;
514f1c67 2792}
ubuntu-bionic-kernel mirror