]> 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 build: Move feature checks code under tools/build
[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;
1138 const char *name;
2ae3a312 1139 bool filtered;
5089f20e 1140 bool is_exit;
514f1c67 1141 struct syscall_fmt *fmt;
01533e97 1142 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1f115cb7 1143 void **arg_parm;
514f1c67
ACM		 1144};
1145
60c907ab
ACM		 1146static size_t fprintf_duration(unsigned long t, FILE *fp)
1147{
1148 double duration = (double)t / NSEC_PER_MSEC;
1149 size_t printed = fprintf(fp, "(");
1150
1151 if (duration >= 1.0)
1152 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1153 else if (duration >= 0.01)
1154 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1155 else
1156 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
c24ff998 1157 return printed + fprintf(fp, "): ");
60c907ab
ACM		 1158}
1159
752fde44
ACM		 1160struct thread_trace {
1161 u64 entry_time;
1162 u64 exit_time;
1163 bool entry_pending;
efd5745e 1164 unsigned long nr_events;
a2ea67d7 1165 unsigned long pfmaj, pfmin;
752fde44 1166 char *entry_str;
1302d88e 1167 double runtime_ms;
75b757ca
ACM		 1168 struct {
1169 int max;
1170 char **table;
1171 } paths;
bf2575c1
DA		 1172
1173 struct intlist *syscall_stats;
752fde44
ACM		 1174};
1175
1176static struct thread_trace *thread_trace__new(void)
1177{
75b757ca
ACM		 1178 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1179
1180 if (ttrace)
1181 ttrace->paths.max = -1;
1182
bf2575c1
DA		 1183 ttrace->syscall_stats = intlist__new(NULL);
1184
75b757ca 1185 return ttrace;
752fde44
ACM		 1186}
1187
c24ff998 1188static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
752fde44 1189{
efd5745e
ACM		 1190 struct thread_trace *ttrace;
1191
752fde44
ACM		 1192 if (thread == NULL)
1193 goto fail;
1194
89dceb22
NK		 1195 if (thread__priv(thread) == NULL)
1196 thread__set_priv(thread, thread_trace__new());
48000a1a 1197
89dceb22 1198 if (thread__priv(thread) == NULL)
752fde44
ACM		 1199 goto fail;
1200
89dceb22 1201 ttrace = thread__priv(thread);
efd5745e
ACM		 1202 ++ttrace->nr_events;
1203
1204 return ttrace;
752fde44 1205fail:
c24ff998 1206 color_fprintf(fp, PERF_COLOR_RED,
752fde44
ACM		 1207 "WARNING: not enough memory, dropping samples!\n");
1208 return NULL;
1209}
1210
598d02c5
SF		 1211#define TRACE_PFMAJ (1 << 0)
1212#define TRACE_PFMIN (1 << 1)
1213
514f1c67 1214struct trace {
c24ff998 1215 struct perf_tool tool;
c522739d
ACM		 1216 struct {
1217 int machine;
1218 int open_id;
1219 } audit;
514f1c67
ACM		 1220 struct {
1221 int max;
1222 struct syscall *table;
1223 } syscalls;
b4006796 1224 struct record_opts opts;
14a052df 1225 struct perf_evlist *evlist;
8fb598e5 1226 struct machine *host;
e596663e 1227 struct thread *current;
752fde44 1228 u64 base_time;
c24ff998 1229 FILE *output;
efd5745e 1230 unsigned long nr_events;
b059efdf 1231 struct strlist *ev_qualifier;
c522739d 1232 const char *last_vfs_getname;
bdc89661
DA		 1233 struct intlist *tid_list;
1234 struct intlist *pid_list;
f078c385
ACM		 1235 struct {
1236 size_t nr;
1237 pid_t *entries;
1238 } filter_pids;
98eafce6
ACM		 1239 double duration_filter;
1240 double runtime_ms;
1241 struct {
1242 u64 vfs_getname,
1243 proc_getname;
1244 } stats;
1245 bool not_ev_qualifier;
1246 bool live;
1247 bool full_time;
1302d88e 1248 bool sched;
752fde44 1249 bool multiple_threads;
bf2575c1 1250 bool summary;
fd2eabaf 1251 bool summary_only;
50c95cbd 1252 bool show_comm;
c522739d 1253 bool show_tool_stats;
e281a960 1254 bool trace_syscalls;
598d02c5 1255 int trace_pgfaults;
514f1c67
ACM		 1256};
1257
97119f37 1258static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
75b757ca 1259{
89dceb22 1260 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1261
1262 if (fd > ttrace->paths.max) {
1263 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1264
1265 if (npath == NULL)
1266 return -1;
1267
1268 if (ttrace->paths.max != -1) {
1269 memset(npath + ttrace->paths.max + 1, 0,
1270 (fd - ttrace->paths.max) * sizeof(char *));
1271 } else {
1272 memset(npath, 0, (fd + 1) * sizeof(char *));
1273 }
1274
1275 ttrace->paths.table = npath;
1276 ttrace->paths.max = fd;
1277 }
1278
1279 ttrace->paths.table[fd] = strdup(pathname);
1280
1281 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1282}
1283
97119f37
ACM		 1284static int thread__read_fd_path(struct thread *thread, int fd)
1285{
1286 char linkname[PATH_MAX], pathname[PATH_MAX];
1287 struct stat st;
1288 int ret;
1289
1290 if (thread->pid_ == thread->tid) {
1291 scnprintf(linkname, sizeof(linkname),
1292 "/proc/%d/fd/%d", thread->pid_, fd);
1293 } else {
1294 scnprintf(linkname, sizeof(linkname),
1295 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1296 }
1297
1298 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1299 return -1;
1300
1301 ret = readlink(linkname, pathname, sizeof(pathname));
1302
1303 if (ret < 0 || ret > st.st_size)
1304 return -1;
1305
1306 pathname[ret] = '\0';
1307 return trace__set_fd_pathname(thread, fd, pathname);
1308}
1309
c522739d
ACM		 1310static const char *thread__fd_path(struct thread *thread, int fd,
1311 struct trace *trace)
75b757ca 1312{
89dceb22 1313 struct thread_trace *ttrace = thread__priv(thread);
75b757ca
ACM		 1314
1315 if (ttrace == NULL)
1316 return NULL;
1317
1318 if (fd < 0)
1319 return NULL;
1320
cdcd1e6b 1321 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
c522739d
ACM		 1322 if (!trace->live)
1323 return NULL;
1324 ++trace->stats.proc_getname;
cdcd1e6b 1325 if (thread__read_fd_path(thread, fd))
c522739d
ACM		 1326 return NULL;
1327 }
75b757ca
ACM		 1328
1329 return ttrace->paths.table[fd];
1330}
1331
1332static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1333 struct syscall_arg *arg)
1334{
1335 int fd = arg->val;
1336 size_t printed = scnprintf(bf, size, "%d", fd);
c522739d 1337 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
75b757ca
ACM		 1338
1339 if (path)
1340 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1341
1342 return printed;
1343}
1344
1345static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1346 struct syscall_arg *arg)
1347{
1348 int fd = arg->val;
1349 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
89dceb22 1350 struct thread_trace *ttrace = thread__priv(arg->thread);
75b757ca 1351
04662523
ACM		 1352 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1353 zfree(&ttrace->paths.table[fd]);
75b757ca
ACM		 1354
1355 return printed;
1356}
1357
ae9ed035
ACM		 1358static bool trace__filter_duration(struct trace *trace, double t)
1359{
1360 return t < (trace->duration_filter * NSEC_PER_MSEC);
1361}
1362
752fde44
ACM		 1363static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1364{
1365 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1366
60c907ab 1367 return fprintf(fp, "%10.3f ", ts);
752fde44
ACM		 1368}
1369
f15eb531 1370static bool done = false;
ba209f85 1371static bool interrupted = false;
f15eb531 1372
ba209f85 1373static void sig_handler(int sig)
f15eb531
NK		 1374{
1375 done = true;
ba209f85 1376 interrupted = sig == SIGINT;
f15eb531
NK		 1377}
1378
752fde44 1379static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
60c907ab 1380 u64 duration, u64 tstamp, FILE *fp)
752fde44
ACM		 1381{
1382 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
60c907ab 1383 printed += fprintf_duration(duration, fp);
752fde44 1384
50c95cbd
ACM		 1385 if (trace->multiple_threads) {
1386 if (trace->show_comm)
1902efe7 1387 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
38051234 1388 printed += fprintf(fp, "%d ", thread->tid);
50c95cbd 1389 }
752fde44
ACM		 1390
1391 return printed;
1392}
1393
c24ff998 1394static int trace__process_event(struct trace *trace, struct machine *machine,
162f0bef 1395 union perf_event *event, struct perf_sample *sample)
752fde44
ACM		 1396{
1397 int ret = 0;
1398
1399 switch (event->header.type) {
1400 case PERF_RECORD_LOST:
c24ff998 1401 color_fprintf(trace->output, PERF_COLOR_RED,
752fde44 1402 "LOST %" PRIu64 " events!\n", event->lost.lost);
162f0bef 1403 ret = machine__process_lost_event(machine, event, sample);
752fde44 1404 default:
162f0bef 1405 ret = machine__process_event(machine, event, sample);
752fde44
ACM		 1406 break;
1407 }
1408
1409 return ret;
1410}
1411
c24ff998 1412static int trace__tool_process(struct perf_tool *tool,
752fde44 1413 union perf_event *event,
162f0bef 1414 struct perf_sample *sample,
752fde44
ACM		 1415 struct machine *machine)
1416{
c24ff998 1417 struct trace *trace = container_of(tool, struct trace, tool);
162f0bef 1418 return trace__process_event(trace, machine, event, sample);
752fde44
ACM		 1419}
1420
1421static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1422{
0a7e6d1b 1423 int err = symbol__init(NULL);
752fde44
ACM		 1424
1425 if (err)
1426 return err;
1427
8fb598e5
DA		 1428 trace->host = machine__new_host();
1429 if (trace->host == NULL)
1430 return -ENOMEM;
752fde44 1431
a33fbd56
ACM		 1432 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1433 evlist->threads, trace__tool_process, false);
752fde44
ACM		 1434 if (err)
1435 symbol__exit();
1436
1437 return err;
1438}
1439
13d4ff3e
ACM		 1440static int syscall__set_arg_fmts(struct syscall *sc)
1441{
1442 struct format_field *field;
1443 int idx = 0;
1444
1445 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
1446 if (sc->arg_scnprintf == NULL)
1447 return -1;
1448
1f115cb7
ACM		 1449 if (sc->fmt)
1450 sc->arg_parm = sc->fmt->arg_parm;
1451
13d4ff3e 1452 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
beccb2b5
ACM		 1453 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1454 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1455 else if (field->flags & FIELD_IS_POINTER)
13d4ff3e
ACM		 1456 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1457 ++idx;
1458 }
1459
1460 return 0;
1461}
1462
514f1c67
ACM		 1463static int trace__read_syscall_info(struct trace *trace, int id)
1464{
1465 char tp_name[128];
1466 struct syscall *sc;
c522739d 1467 const char *name = audit_syscall_to_name(id, trace->audit.machine);
3a531260
ACM		 1468
1469 if (name == NULL)
1470 return -1;
514f1c67
ACM		 1471
1472 if (id > trace->syscalls.max) {
1473 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1474
1475 if (nsyscalls == NULL)
1476 return -1;
1477
1478 if (trace->syscalls.max != -1) {
1479 memset(nsyscalls + trace->syscalls.max + 1, 0,
1480 (id - trace->syscalls.max) * sizeof(*sc));
1481 } else {
1482 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1483 }
1484
1485 trace->syscalls.table = nsyscalls;
1486 trace->syscalls.max = id;
1487 }
1488
1489 sc = trace->syscalls.table + id;
3a531260 1490 sc->name = name;
2ae3a312 1491
b059efdf
ACM		 1492 if (trace->ev_qualifier) {
1493 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1494
1495 if (!(in ^ trace->not_ev_qualifier)) {
1496 sc->filtered = true;
1497 /*
1498 * No need to do read tracepoint information since this will be
1499 * filtered out.
1500 */
1501 return 0;
1502 }
2ae3a312
ACM		 1503 }
1504
3a531260 1505 sc->fmt = syscall_fmt__find(sc->name);
514f1c67 1506
aec1930b 1507 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
97978b3e 1508 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b
ACM		 1509
1510 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1511 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
97978b3e 1512 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
aec1930b 1513 }
514f1c67 1514
13d4ff3e
ACM		 1515 if (sc->tp_format == NULL)
1516 return -1;
1517
5089f20e
ACM		 1518 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1519
13d4ff3e 1520 return syscall__set_arg_fmts(sc);
514f1c67
ACM		 1521}
1522
55d43bca
DA		 1523/*
1524 * args is to be interpreted as a series of longs but we need to handle
1525 * 8-byte unaligned accesses. args points to raw_data within the event
1526 * and raw_data is guaranteed to be 8-byte unaligned because it is
1527 * preceded by raw_size which is a u32. So we need to copy args to a temp
1528 * variable to read it. Most notably this avoids extended load instructions
1529 * on unaligned addresses
1530 */
1531
752fde44 1532static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
55d43bca 1533 unsigned char *args, struct trace *trace,
75b757ca 1534 struct thread *thread)
514f1c67 1535{
514f1c67 1536 size_t printed = 0;
55d43bca
DA		 1537 unsigned char *p;
1538 unsigned long val;
514f1c67
ACM		 1539
1540 if (sc->tp_format != NULL) {
1541 struct format_field *field;
01533e97
ACM		 1542 u8 bit = 1;
1543 struct syscall_arg arg = {
75b757ca
ACM		 1544 .idx = 0,
1545 .mask = 0,
1546 .trace = trace,
1547 .thread = thread,
01533e97 1548 };
6e7eeb51
ACM		 1549
1550 for (field = sc->tp_format->format.fields->next; field;
01533e97
ACM		 1551 field = field->next, ++arg.idx, bit <<= 1) {
1552 if (arg.mask & bit)
6e7eeb51 1553 continue;
55d43bca
DA		 1554
1555 /* special care for unaligned accesses */
1556 p = args + sizeof(unsigned long) * arg.idx;
1557 memcpy(&val, p, sizeof(val));
1558
4aa58232
ACM		 1559 /*
1560 * Suppress this argument if its value is zero and
1561 * and we don't have a string associated in an
1562 * strarray for it.
1563 */
55d43bca 1564 if (val == 0 &&
4aa58232
ACM		 1565 !(sc->arg_scnprintf &&
1566 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1567 sc->arg_parm[arg.idx]))
22ae5cf1
ACM		 1568 continue;
1569
752fde44 1570 printed += scnprintf(bf + printed, size - printed,
13d4ff3e 1571 "%s%s: ", printed ? ", " : "", field->name);
01533e97 1572 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
55d43bca 1573 arg.val = val;
1f115cb7
ACM		 1574 if (sc->arg_parm)
1575 arg.parm = sc->arg_parm[arg.idx];
01533e97
ACM		 1576 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1577 size - printed, &arg);
6e7eeb51 1578 } else {
13d4ff3e 1579 printed += scnprintf(bf + printed, size - printed,
55d43bca 1580 "%ld", val);
6e7eeb51 1581 }
514f1c67
ACM		 1582 }
1583 } else {
01533e97
ACM		 1584 int i = 0;
1585
514f1c67 1586 while (i < 6) {
55d43bca
DA		 1587 /* special care for unaligned accesses */
1588 p = args + sizeof(unsigned long) * i;
1589 memcpy(&val, p, sizeof(val));
752fde44
ACM		 1590 printed += scnprintf(bf + printed, size - printed,
1591 "%sarg%d: %ld",
55d43bca 1592 printed ? ", " : "", i, val);
514f1c67
ACM		 1593 ++i;
1594 }
1595 }
1596
1597 return printed;
1598}
1599
ba3d7dee 1600typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1601 union perf_event *event,
ba3d7dee
ACM		 1602 struct perf_sample *sample);
1603
1604static struct syscall *trace__syscall_info(struct trace *trace,
bf2575c1 1605 struct perf_evsel *evsel, int id)
ba3d7dee 1606{
ba3d7dee
ACM		 1607
1608 if (id < 0) {
adaa18bf
ACM		 1609
1610 /*
1611 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1612 * before that, leaving at a higher verbosity level till that is
1613 * explained. Reproduced with plain ftrace with:
1614 *
1615 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1616 * grep "NR -1 " /t/trace_pipe
1617 *
1618 * After generating some load on the machine.
1619 */
1620 if (verbose > 1) {
1621 static u64 n;
1622 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1623 id, perf_evsel__name(evsel), ++n);
1624 }
ba3d7dee
ACM		 1625 return NULL;
1626 }
1627
1628 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1629 trace__read_syscall_info(trace, id))
1630 goto out_cant_read;
1631
1632 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1633 goto out_cant_read;
1634
1635 return &trace->syscalls.table[id];
1636
1637out_cant_read:
7c304ee0
ACM		 1638 if (verbose) {
1639 fprintf(trace->output, "Problems reading syscall %d", id);
1640 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1641 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1642 fputs(" information\n", trace->output);
1643 }
ba3d7dee
ACM		 1644 return NULL;
1645}
1646
bf2575c1
DA		 1647static void thread__update_stats(struct thread_trace *ttrace,
1648 int id, struct perf_sample *sample)
1649{
1650 struct int_node *inode;
1651 struct stats *stats;
1652 u64 duration = 0;
1653
1654 inode = intlist__findnew(ttrace->syscall_stats, id);
1655 if (inode == NULL)
1656 return;
1657
1658 stats = inode->priv;
1659 if (stats == NULL) {
1660 stats = malloc(sizeof(struct stats));
1661 if (stats == NULL)
1662 return;
1663 init_stats(stats);
1664 inode->priv = stats;
1665 }
1666
1667 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1668 duration = sample->time - ttrace->entry_time;
1669
1670 update_stats(stats, duration);
1671}
1672
e596663e
ACM		 1673static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1674{
1675 struct thread_trace *ttrace;
1676 u64 duration;
1677 size_t printed;
1678
1679 if (trace->current == NULL)
1680 return 0;
1681
1682 ttrace = thread__priv(trace->current);
1683
1684 if (!ttrace->entry_pending)
1685 return 0;
1686
1687 duration = sample->time - ttrace->entry_time;
1688
1689 printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1690 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1691 ttrace->entry_pending = false;
1692
1693 return printed;
1694}
1695
ba3d7dee 1696static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1697 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1698 struct perf_sample *sample)
1699{
752fde44 1700 char *msg;
ba3d7dee 1701 void *args;
752fde44 1702 size_t printed = 0;
2ae3a312 1703 struct thread *thread;
77170988 1704 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
bf2575c1 1705 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1706 struct thread_trace *ttrace;
1707
1708 if (sc == NULL)
1709 return -1;
ba3d7dee 1710
2ae3a312
ACM		 1711 if (sc->filtered)
1712 return 0;
1713
8fb598e5 1714 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1715 ttrace = thread__trace(thread, trace->output);
2ae3a312 1716 if (ttrace == NULL)
ba3d7dee
ACM		 1717 return -1;
1718
77170988 1719 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
752fde44
ACM		 1720
1721 if (ttrace->entry_str == NULL) {
1722 ttrace->entry_str = malloc(1024);
1723 if (!ttrace->entry_str)
1724 return -1;
1725 }
1726
13f22a2d
DA		 1727 if (!trace->summary_only)
1728 printed += trace__printf_interrupted_entry(trace, sample);
e596663e 1729
752fde44
ACM		 1730 ttrace->entry_time = sample->time;
1731 msg = ttrace->entry_str;
1732 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1733
75b757ca
ACM		 1734 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1735 args, trace, thread);
752fde44 1736
5089f20e 1737 if (sc->is_exit) {
fd2eabaf 1738 if (!trace->duration_filter && !trace->summary_only) {
c24ff998
ACM		 1739 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1740 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
ae9ed035 1741 }
752fde44
ACM		 1742 } else
1743 ttrace->entry_pending = true;
ba3d7dee 1744
f3b623b8
ACM		 1745 if (trace->current != thread) {
1746 thread__put(trace->current);
1747 trace->current = thread__get(thread);
1748 }
e596663e 1749
ba3d7dee
ACM		 1750 return 0;
1751}
1752
1753static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1754 union perf_event *event __maybe_unused,
ba3d7dee
ACM		 1755 struct perf_sample *sample)
1756{
2c82c3ad 1757 long ret;
60c907ab 1758 u64 duration = 0;
2ae3a312 1759 struct thread *thread;
77170988 1760 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
bf2575c1 1761 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1762 struct thread_trace *ttrace;
1763
1764 if (sc == NULL)
1765 return -1;
ba3d7dee 1766
2ae3a312
ACM		 1767 if (sc->filtered)
1768 return 0;
1769
8fb598e5 1770 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1771 ttrace = thread__trace(thread, trace->output);
2ae3a312 1772 if (ttrace == NULL)
ba3d7dee
ACM		 1773 return -1;
1774
bf2575c1
DA		 1775 if (trace->summary)
1776 thread__update_stats(ttrace, id, sample);
1777
77170988 1778 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
ba3d7dee 1779
c522739d
ACM		 1780 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1781 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1782 trace->last_vfs_getname = NULL;
1783 ++trace->stats.vfs_getname;
1784 }
1785
752fde44
ACM		 1786 ttrace->exit_time = sample->time;
1787
ae9ed035 1788 if (ttrace->entry_time) {
60c907ab 1789 duration = sample->time - ttrace->entry_time;
ae9ed035
ACM		 1790 if (trace__filter_duration(trace, duration))
1791 goto out;
1792 } else if (trace->duration_filter)
1793 goto out;
60c907ab 1794
fd2eabaf
DA		 1795 if (trace->summary_only)
1796 goto out;
1797
c24ff998 1798 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
752fde44
ACM		 1799
1800 if (ttrace->entry_pending) {
c24ff998 1801 fprintf(trace->output, "%-70s", ttrace->entry_str);
752fde44 1802 } else {
c24ff998
ACM		 1803 fprintf(trace->output, " ... [");
1804 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1805 fprintf(trace->output, "]: %s()", sc->name);
752fde44
ACM		 1806 }
1807
da3c9a44
ACM		 1808 if (sc->fmt == NULL) {
1809signed_print:
2c82c3ad 1810 fprintf(trace->output, ") = %ld", ret);
da3c9a44 1811 } else if (ret < 0 && sc->fmt->errmsg) {
942a91ed 1812 char bf[STRERR_BUFSIZE];
ba3d7dee
ACM		 1813 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1814 *e = audit_errno_to_name(-ret);
1815
c24ff998 1816 fprintf(trace->output, ") = -1 %s %s", e, emsg);
da3c9a44 1817 } else if (ret == 0 && sc->fmt->timeout)
c24ff998 1818 fprintf(trace->output, ") = 0 Timeout");
04b34729 1819 else if (sc->fmt->hexret)
2c82c3ad 1820 fprintf(trace->output, ") = %#lx", ret);
ba3d7dee 1821 else
da3c9a44 1822 goto signed_print;
ba3d7dee 1823
c24ff998 1824 fputc('\n', trace->output);
ae9ed035 1825out:
752fde44
ACM		 1826 ttrace->entry_pending = false;
1827
ba3d7dee
ACM		 1828 return 0;
1829}
1830
c522739d 1831static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1832 union perf_event *event __maybe_unused,
c522739d
ACM		 1833 struct perf_sample *sample)
1834{
1835 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1836 return 0;
1837}
1838
1302d88e 1839static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
0c82adcf 1840 union perf_event *event __maybe_unused,
1302d88e
ACM		 1841 struct perf_sample *sample)
1842{
1843 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1844 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
8fb598e5 1845 struct thread *thread = machine__findnew_thread(trace->host,
314add6b
AH		 1846 sample->pid,
1847 sample->tid);
c24ff998 1848 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1302d88e
ACM		 1849
1850 if (ttrace == NULL)
1851 goto out_dump;
1852
1853 ttrace->runtime_ms += runtime_ms;
1854 trace->runtime_ms += runtime_ms;
1855 return 0;
1856
1857out_dump:
c24ff998 1858 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1302d88e
ACM		 1859 evsel->name,
1860 perf_evsel__strval(evsel, sample, "comm"),
1861 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1862 runtime,
1863 perf_evsel__intval(evsel, sample, "vruntime"));
1864 return 0;
1865}
1866
14a052df
ACM		 1867static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1868 union perf_event *event __maybe_unused,
1869 struct perf_sample *sample)
1870{
1871 trace__printf_interrupted_entry(trace, sample);
1872 trace__fprintf_tstamp(trace, sample->time, trace->output);
0808921a
ACM		 1873
1874 if (trace->trace_syscalls)
1875 fprintf(trace->output, "( ): ");
1876
1877 fprintf(trace->output, "%s:", evsel->name);
14a052df
ACM		 1878
1879 if (evsel->tp_format) {
1880 event_format__fprintf(evsel->tp_format, sample->cpu,
1881 sample->raw_data, sample->raw_size,
1882 trace->output);
1883 }
1884
1885 fprintf(trace->output, ")\n");
1886 return 0;
1887}
1888
598d02c5
SF		 1889static void print_location(FILE *f, struct perf_sample *sample,
1890 struct addr_location *al,
1891 bool print_dso, bool print_sym)
1892{
1893
1894 if ((verbose || print_dso) && al->map)
1895 fprintf(f, "%s@", al->map->dso->long_name);
1896
1897 if ((verbose || print_sym) && al->sym)
4414a3c5 1898 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
598d02c5
SF		 1899 al->addr - al->sym->start);
1900 else if (al->map)
4414a3c5 1901 fprintf(f, "0x%" PRIx64, al->addr);
598d02c5 1902 else
4414a3c5 1903 fprintf(f, "0x%" PRIx64, sample->addr);
598d02c5
SF		 1904}
1905
1906static int trace__pgfault(struct trace *trace,
1907 struct perf_evsel *evsel,
1908 union perf_event *event,
1909 struct perf_sample *sample)
1910{
1911 struct thread *thread;
1912 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1913 struct addr_location al;
1914 char map_type = 'd';
a2ea67d7 1915 struct thread_trace *ttrace;
598d02c5
SF		 1916
1917 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
a2ea67d7
SF		 1918 ttrace = thread__trace(thread, trace->output);
1919 if (ttrace == NULL)
1920 return -1;
1921
1922 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
1923 ttrace->pfmaj++;
1924 else
1925 ttrace->pfmin++;
1926
1927 if (trace->summary_only)
1928 return 0;
598d02c5 1929
bb871a9c 1930 thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
598d02c5
SF		 1931 sample->ip, &al);
1932
1933 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1934
1935 fprintf(trace->output, "%sfault [",
1936 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1937 "maj" : "min");
1938
1939 print_location(trace->output, sample, &al, false, true);
1940
1941 fprintf(trace->output, "] => ");
1942
bb871a9c 1943 thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
598d02c5
SF		 1944 sample->addr, &al);
1945
1946 if (!al.map) {
bb871a9c 1947 thread__find_addr_location(thread, cpumode,
598d02c5
SF		 1948 MAP__FUNCTION, sample->addr, &al);
1949
1950 if (al.map)
1951 map_type = 'x';
1952 else
1953 map_type = '?';
1954 }
1955
1956 print_location(trace->output, sample, &al, true, false);
1957
1958 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1959
1960 return 0;
1961}
1962
bdc89661
DA		 1963static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1964{
1965 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1966 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1967 return false;
1968
1969 if (trace->pid_list || trace->tid_list)
1970 return true;
1971
1972 return false;
1973}
1974
6810fc91 1975static int trace__process_sample(struct perf_tool *tool,
0c82adcf 1976 union perf_event *event,
6810fc91
DA		 1977 struct perf_sample *sample,
1978 struct perf_evsel *evsel,
1979 struct machine *machine __maybe_unused)
1980{
1981 struct trace *trace = container_of(tool, struct trace, tool);
1982 int err = 0;
1983
744a9719 1984 tracepoint_handler handler = evsel->handler;
6810fc91 1985
bdc89661
DA		 1986 if (skip_sample(trace, sample))
1987 return 0;
1988
4bb09192 1989 if (!trace->full_time && trace->base_time == 0)
6810fc91
DA		 1990 trace->base_time = sample->time;
1991
3160565f
DA		 1992 if (handler) {
1993 ++trace->nr_events;
0c82adcf 1994 handler(trace, evsel, event, sample);
3160565f 1995 }
6810fc91
DA		 1996
1997 return err;
1998}
1999
bdc89661
DA		 2000static int parse_target_str(struct trace *trace)
2001{
2002 if (trace->opts.target.pid) {
2003 trace->pid_list = intlist__new(trace->opts.target.pid);
2004 if (trace->pid_list == NULL) {
2005 pr_err("Error parsing process id string\n");
2006 return -EINVAL;
2007 }
2008 }
2009
2010 if (trace->opts.target.tid) {
2011 trace->tid_list = intlist__new(trace->opts.target.tid);
2012 if (trace->tid_list == NULL) {
2013 pr_err("Error parsing thread id string\n");
2014 return -EINVAL;
2015 }
2016 }
2017
2018 return 0;
2019}
2020
1e28fe0a 2021static int trace__record(struct trace *trace, int argc, const char **argv)
5e2485b1
DA		 2022{
2023 unsigned int rec_argc, i, j;
2024 const char **rec_argv;
2025 const char * const record_args[] = {
2026 "record",
2027 "-R",
2028 "-m", "1024",
2029 "-c", "1",
5e2485b1
DA		 2030 };
2031
1e28fe0a
SF		 2032 const char * const sc_args[] = { "-e", };
2033 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2034 const char * const majpf_args[] = { "-e", "major-faults" };
2035 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2036 const char * const minpf_args[] = { "-e", "minor-faults" };
2037 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2038
9aca7f17 2039 /* +1 is for the event string below */
1e28fe0a
SF		 2040 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2041 majpf_args_nr + minpf_args_nr + argc;
5e2485b1
DA		 2042 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2043
2044 if (rec_argv == NULL)
2045 return -ENOMEM;
2046
1e28fe0a 2047 j = 0;
5e2485b1 2048 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1e28fe0a
SF		 2049 rec_argv[j++] = record_args[i];
2050
e281a960
SF		 2051 if (trace->trace_syscalls) {
2052 for (i = 0; i < sc_args_nr; i++)
2053 rec_argv[j++] = sc_args[i];
2054
2055 /* event string may be different for older kernels - e.g., RHEL6 */
2056 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2057 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2058 else if (is_valid_tracepoint("syscalls:sys_enter"))
2059 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2060 else {
2061 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2062 return -1;
2063 }
9aca7f17 2064 }
9aca7f17 2065
1e28fe0a
SF		 2066 if (trace->trace_pgfaults & TRACE_PFMAJ)
2067 for (i = 0; i < majpf_args_nr; i++)
2068 rec_argv[j++] = majpf_args[i];
2069
2070 if (trace->trace_pgfaults & TRACE_PFMIN)
2071 for (i = 0; i < minpf_args_nr; i++)
2072 rec_argv[j++] = minpf_args[i];
2073
2074 for (i = 0; i < (unsigned int)argc; i++)
2075 rec_argv[j++] = argv[i];
5e2485b1 2076
1e28fe0a 2077 return cmd_record(j, rec_argv, NULL);
5e2485b1
DA		 2078}
2079
bf2575c1
DA		 2080static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2081
c522739d
ACM		 2082static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2083{
ef503831 2084 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
c522739d
ACM		 2085 if (evsel == NULL)
2086 return;
2087
2088 if (perf_evsel__field(evsel, "pathname") == NULL) {
2089 perf_evsel__delete(evsel);
2090 return;
2091 }
2092
744a9719 2093 evsel->handler = trace__vfs_getname;
c522739d
ACM		 2094 perf_evlist__add(evlist, evsel);
2095}
2096
598d02c5
SF		 2097static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
2098 u64 config)
2099{
2100 struct perf_evsel *evsel;
2101 struct perf_event_attr attr = {
2102 .type = PERF_TYPE_SOFTWARE,
2103 .mmap_data = 1,
598d02c5
SF		 2104 };
2105
2106 attr.config = config;
0524798c 2107 attr.sample_period = 1;
598d02c5
SF		 2108
2109 event_attr_init(&attr);
2110
2111 evsel = perf_evsel__new(&attr);
2112 if (!evsel)
2113 return -ENOMEM;
2114
2115 evsel->handler = trace__pgfault;
2116 perf_evlist__add(evlist, evsel);
2117
2118 return 0;
2119}
2120
ddbb1b13
ACM		 2121static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2122{
2123 const u32 type = event->header.type;
2124 struct perf_evsel *evsel;
2125
2126 if (!trace->full_time && trace->base_time == 0)
2127 trace->base_time = sample->time;
2128
2129 if (type != PERF_RECORD_SAMPLE) {
2130 trace__process_event(trace, trace->host, event, sample);
2131 return;
2132 }
2133
2134 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2135 if (evsel == NULL) {
2136 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2137 return;
2138 }
2139
2140 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2141 sample->raw_data == NULL) {
2142 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2143 perf_evsel__name(evsel), sample->tid,
2144 sample->cpu, sample->raw_size);
2145 } else {
2146 tracepoint_handler handler = evsel->handler;
2147 handler(trace, evsel, event, sample);
2148 }
2149}
2150
f15eb531 2151static int trace__run(struct trace *trace, int argc, const char **argv)
514f1c67 2152{
14a052df 2153 struct perf_evlist *evlist = trace->evlist;
efd5745e
ACM		 2154 int err = -1, i;
2155 unsigned long before;
f15eb531 2156 const bool forks = argc > 0;
46fb3c21 2157 bool draining = false;
514f1c67 2158
75b757ca
ACM		 2159 trace->live = true;
2160
e281a960
SF		 2161 if (trace->trace_syscalls &&
2162 perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
2163 trace__sys_exit))
801c67b0 2164 goto out_error_raw_syscalls;
514f1c67 2165
e281a960
SF		 2166 if (trace->trace_syscalls)
2167 perf_evlist__add_vfs_getname(evlist);
c522739d 2168
598d02c5 2169 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
e2726d99 2170 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
5ed08dae 2171 goto out_error_mem;
e2726d99 2172 }
598d02c5
SF		 2173
2174 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2175 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
5ed08dae 2176 goto out_error_mem;
598d02c5 2177
1302d88e 2178 if (trace->sched &&
2cc990ba
ACM		 2179 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2180 trace__sched_stat_runtime))
2181 goto out_error_sched_stat_runtime;
1302d88e 2182
514f1c67
ACM		 2183 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2184 if (err < 0) {
c24ff998 2185 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
514f1c67
ACM		 2186 goto out_delete_evlist;
2187 }
2188
752fde44
ACM		 2189 err = trace__symbols_init(trace, evlist);
2190 if (err < 0) {
c24ff998 2191 fprintf(trace->output, "Problems initializing symbol libraries!\n");
03ad9747 2192 goto out_delete_evlist;
752fde44
ACM		 2193 }
2194
f77a9518 2195 perf_evlist__config(evlist, &trace->opts);
514f1c67 2196
f15eb531
NK		 2197 signal(SIGCHLD, sig_handler);
2198 signal(SIGINT, sig_handler);
2199
2200 if (forks) {
6ef73ec4 2201 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
735f7e0b 2202 argv, false, NULL);
f15eb531 2203 if (err < 0) {
c24ff998 2204 fprintf(trace->output, "Couldn't run the workload!\n");
03ad9747 2205 goto out_delete_evlist;
f15eb531
NK		 2206 }
2207 }
2208
514f1c67 2209 err = perf_evlist__open(evlist);
a8f23d8f
ACM		 2210 if (err < 0)
2211 goto out_error_open;
514f1c67 2212
241b057c
ACM		 2213 /*
2214 * Better not use !target__has_task() here because we need to cover the
2215 * case where no threads were specified in the command line, but a
2216 * workload was, and in that case we will fill in the thread_map when
2217 * we fork the workload in perf_evlist__prepare_workload.
2218 */
f078c385
ACM		 2219 if (trace->filter_pids.nr > 0)
2220 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2221 else if (evlist->threads->map[0] == -1)
2222 err = perf_evlist__set_filter_pid(evlist, getpid());
2223
2224 if (err < 0) {
2225 printf("err=%d,%s\n", -err, strerror(-err));
2226 exit(1);
2227 }
241b057c 2228
f885037e 2229 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
e09b18d4
ACM		 2230 if (err < 0)
2231 goto out_error_mmap;
514f1c67 2232
f15eb531
NK		 2233 if (forks)
2234 perf_evlist__start_workload(evlist);
f7aa222f
ACM		 2235 else
2236 perf_evlist__enable(evlist);
f15eb531 2237
42052bea
ACM		 2238 trace->multiple_threads = evlist->threads->map[0] == -1 ||
2239 evlist->threads->nr > 1 ||
2240 perf_evlist__first(evlist)->attr.inherit;
514f1c67 2241again:
efd5745e 2242 before = trace->nr_events;
514f1c67
ACM		 2243
2244 for (i = 0; i < evlist->nr_mmaps; i++) {
2245 union perf_event *event;
2246
2247 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
514f1c67 2248 struct perf_sample sample;
514f1c67 2249
efd5745e 2250 ++trace->nr_events;
514f1c67 2251
514f1c67
ACM		 2252 err = perf_evlist__parse_sample(evlist, event, &sample);
2253 if (err) {
c24ff998 2254 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
8e50d384 2255 goto next_event;
514f1c67
ACM		 2256 }
2257
ddbb1b13 2258 trace__handle_event(trace, event, &sample);
8e50d384
ZZ		 2259next_event:
2260 perf_evlist__mmap_consume(evlist, i);
20c5f10e 2261
ba209f85
ACM		 2262 if (interrupted)
2263 goto out_disable;
514f1c67
ACM		 2264 }
2265 }
2266
efd5745e 2267 if (trace->nr_events == before) {
ba209f85 2268 int timeout = done ? 100 : -1;
f15eb531 2269
46fb3c21
ACM		 2270 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2271 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2272 draining = true;
2273
ba209f85 2274 goto again;
46fb3c21 2275 }
ba209f85
ACM		 2276 } else {
2277 goto again;
f15eb531
NK		 2278 }
2279
ba209f85 2280out_disable:
f3b623b8
ACM		 2281 thread__zput(trace->current);
2282
ba209f85 2283 perf_evlist__disable(evlist);
514f1c67 2284
c522739d
ACM		 2285 if (!err) {
2286 if (trace->summary)
2287 trace__fprintf_thread_summary(trace, trace->output);
2288
2289 if (trace->show_tool_stats) {
2290 fprintf(trace->output, "Stats:\n "
2291 " vfs_getname : %" PRIu64 "\n"
2292 " proc_getname: %" PRIu64 "\n",
2293 trace->stats.vfs_getname,
2294 trace->stats.proc_getname);
2295 }
2296 }
bf2575c1 2297
514f1c67
ACM		 2298out_delete_evlist:
2299 perf_evlist__delete(evlist);
14a052df 2300 trace->evlist = NULL;
75b757ca 2301 trace->live = false;
514f1c67 2302 return err;
6ef068cb
ACM		 2303{
2304 char errbuf[BUFSIZ];
a8f23d8f 2305
2cc990ba
ACM		 2306out_error_sched_stat_runtime:
2307 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2308 goto out_error;
2309
801c67b0 2310out_error_raw_syscalls:
2cc990ba 2311 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
a8f23d8f
ACM		 2312 goto out_error;
2313
e09b18d4
ACM		 2314out_error_mmap:
2315 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2316 goto out_error;
2317
a8f23d8f
ACM		 2318out_error_open:
2319 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2320
2321out_error:
6ef068cb 2322 fprintf(trace->output, "%s\n", errbuf);
87f91868 2323 goto out_delete_evlist;
514f1c67 2324}
5ed08dae
ACM		 2325out_error_mem:
2326 fprintf(trace->output, "Not enough memory to run!\n");
2327 goto out_delete_evlist;
a8f23d8f 2328}
514f1c67 2329
6810fc91
DA		 2330static int trace__replay(struct trace *trace)
2331{
2332 const struct perf_evsel_str_handler handlers[] = {
c522739d 2333 { "probe:vfs_getname", trace__vfs_getname, },
6810fc91 2334 };
f5fc1412
JO		 2335 struct perf_data_file file = {
2336 .path = input_name,
2337 .mode = PERF_DATA_MODE_READ,
2338 };
6810fc91 2339 struct perf_session *session;
003824e8 2340 struct perf_evsel *evsel;
6810fc91
DA		 2341 int err = -1;
2342
2343 trace->tool.sample = trace__process_sample;
2344 trace->tool.mmap = perf_event__process_mmap;
384c671e 2345 trace->tool.mmap2 = perf_event__process_mmap2;
6810fc91
DA		 2346 trace->tool.comm = perf_event__process_comm;
2347 trace->tool.exit = perf_event__process_exit;
2348 trace->tool.fork = perf_event__process_fork;
2349 trace->tool.attr = perf_event__process_attr;
2350 trace->tool.tracing_data = perf_event__process_tracing_data;
2351 trace->tool.build_id = perf_event__process_build_id;
2352
0a8cb85c 2353 trace->tool.ordered_events = true;
6810fc91
DA		 2354 trace->tool.ordering_requires_timestamps = true;
2355
2356 /* add tid to output */
2357 trace->multiple_threads = true;
2358
f5fc1412 2359 session = perf_session__new(&file, false, &trace->tool);
6810fc91 2360 if (session == NULL)
52e02834 2361 return -1;
6810fc91 2362
0a7e6d1b 2363 if (symbol__init(&session->header.env) < 0)
cb2ffae2
NK		 2364 goto out;
2365
8fb598e5
DA		 2366 trace->host = &session->machines.host;
2367
6810fc91
DA		 2368 err = perf_session__set_tracepoints_handlers(session, handlers);
2369 if (err)
2370 goto out;
2371
003824e8
NK		 2372 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2373 "raw_syscalls:sys_enter");
9aca7f17
DA		 2374 /* older kernels have syscalls tp versus raw_syscalls */
2375 if (evsel == NULL)
2376 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2377 "syscalls:sys_enter");
003824e8 2378
e281a960
SF		 2379 if (evsel &&
2380 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2381 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
003824e8
NK		 2382 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2383 goto out;
2384 }
2385
2386 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2387 "raw_syscalls:sys_exit");
9aca7f17
DA		 2388 if (evsel == NULL)
2389 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2390 "syscalls:sys_exit");
e281a960
SF		 2391 if (evsel &&
2392 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2393 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
003824e8 2394 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
6810fc91
DA		 2395 goto out;
2396 }
2397
1e28fe0a
SF		 2398 evlist__for_each(session->evlist, evsel) {
2399 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2400 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2401 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2402 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2403 evsel->handler = trace__pgfault;
2404 }
2405
bdc89661
DA		 2406 err = parse_target_str(trace);
2407 if (err != 0)
2408 goto out;
2409
6810fc91
DA		 2410 setup_pager();
2411
b7b61cbe 2412 err = perf_session__process_events(session);
6810fc91
DA		 2413 if (err)
2414 pr_err("Failed to process events, error %d", err);
2415
bf2575c1
DA		 2416 else if (trace->summary)
2417 trace__fprintf_thread_summary(trace, trace->output);
2418
6810fc91
DA		 2419out:
2420 perf_session__delete(session);
2421
2422 return err;
2423}
2424
1302d88e
ACM		 2425static size_t trace__fprintf_threads_header(FILE *fp)
2426{
2427 size_t printed;
2428
99ff7150 2429 printed = fprintf(fp, "\n Summary of events:\n\n");
bf2575c1
DA		 2430
2431 return printed;
2432}
2433
2434static size_t thread__dump_stats(struct thread_trace *ttrace,
2435 struct trace *trace, FILE *fp)
2436{
2437 struct stats *stats;
2438 size_t printed = 0;
2439 struct syscall *sc;
2440 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2441
2442 if (inode == NULL)
2443 return 0;
2444
2445 printed += fprintf(fp, "\n");
2446
27a778b5
PE		 2447 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2448 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2449 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
99ff7150 2450
bf2575c1
DA		 2451 /* each int_node is a syscall */
2452 while (inode) {
2453 stats = inode->priv;
2454 if (stats) {
2455 double min = (double)(stats->min) / NSEC_PER_MSEC;
2456 double max = (double)(stats->max) / NSEC_PER_MSEC;
2457 double avg = avg_stats(stats);
2458 double pct;
2459 u64 n = (u64) stats->n;
2460
2461 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2462 avg /= NSEC_PER_MSEC;
2463
2464 sc = &trace->syscalls.table[inode->i];
99ff7150 2465 printed += fprintf(fp, " %-15s", sc->name);
27a778b5 2466 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
7f7a4138 2467 n, min, avg);
27a778b5 2468 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
bf2575c1
DA		 2469 }
2470
2471 inode = intlist__next(inode);
2472 }
2473
2474 printed += fprintf(fp, "\n\n");
1302d88e
ACM		 2475
2476 return printed;
2477}
2478
896cbb56
DA		 2479/* struct used to pass data to per-thread function */
2480struct summary_data {
2481 FILE *fp;
2482 struct trace *trace;
2483 size_t printed;
2484};
2485
2486static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2487{
2488 struct summary_data *data = priv;
2489 FILE *fp = data->fp;
2490 size_t printed = data->printed;
2491 struct trace *trace = data->trace;
89dceb22 2492 struct thread_trace *ttrace = thread__priv(thread);
896cbb56
DA		 2493 double ratio;
2494
2495 if (ttrace == NULL)
2496 return 0;
2497
2498 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2499
15e65c69 2500 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
99ff7150 2501 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
15e65c69 2502 printed += fprintf(fp, "%.1f%%", ratio);
a2ea67d7
SF		 2503 if (ttrace->pfmaj)
2504 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2505 if (ttrace->pfmin)
2506 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
99ff7150 2507 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
bf2575c1 2508 printed += thread__dump_stats(ttrace, trace, fp);
896cbb56
DA		 2509
2510 data->printed += printed;
2511
2512 return 0;
2513}
2514
1302d88e
ACM		 2515static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2516{
896cbb56
DA		 2517 struct summary_data data = {
2518 .fp = fp,
2519 .trace = trace
2520 };
2521 data.printed = trace__fprintf_threads_header(fp);
1302d88e 2522
896cbb56
DA		 2523 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2524
2525 return data.printed;
1302d88e
ACM		 2526}
2527
ae9ed035
ACM		 2528static int trace__set_duration(const struct option *opt, const char *str,
2529 int unset __maybe_unused)
2530{
2531 struct trace *trace = opt->value;
2532
2533 trace->duration_filter = atof(str);
2534 return 0;
2535}
2536
f078c385
ACM		 2537static int trace__set_filter_pids(const struct option *opt, const char *str,
2538 int unset __maybe_unused)
2539{
2540 int ret = -1;
2541 size_t i;
2542 struct trace *trace = opt->value;
2543 /*
2544 * FIXME: introduce a intarray class, plain parse csv and create a
2545 * { int nr, int entries[] } struct...
2546 */
2547 struct intlist *list = intlist__new(str);
2548
2549 if (list == NULL)
2550 return -1;
2551
2552 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2553 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2554
2555 if (trace->filter_pids.entries == NULL)
2556 goto out;
2557
2558 trace->filter_pids.entries[0] = getpid();
2559
2560 for (i = 1; i < trace->filter_pids.nr; ++i)
2561 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2562
2563 intlist__delete(list);
2564 ret = 0;
2565out:
2566 return ret;
2567}
2568
c24ff998
ACM		 2569static int trace__open_output(struct trace *trace, const char *filename)
2570{
2571 struct stat st;
2572
2573 if (!stat(filename, &st) && st.st_size) {
2574 char oldname[PATH_MAX];
2575
2576 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2577 unlink(oldname);
2578 rename(filename, oldname);
2579 }
2580
2581 trace->output = fopen(filename, "w");
2582
2583 return trace->output == NULL ? -errno : 0;
2584}
2585
598d02c5
SF		 2586static int parse_pagefaults(const struct option *opt, const char *str,
2587 int unset __maybe_unused)
2588{
2589 int *trace_pgfaults = opt->value;
2590
2591 if (strcmp(str, "all") == 0)
2592 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2593 else if (strcmp(str, "maj") == 0)
2594 *trace_pgfaults |= TRACE_PFMAJ;
2595 else if (strcmp(str, "min") == 0)
2596 *trace_pgfaults |= TRACE_PFMIN;
2597 else
2598 return -1;
2599
2600 return 0;
2601}
2602
14a052df
ACM		 2603static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2604{
2605 struct perf_evsel *evsel;
2606
2607 evlist__for_each(evlist, evsel)
2608 evsel->handler = handler;
2609}
2610
514f1c67
ACM		 2611int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2612{
6fdd9cb7 2613 const char *trace_usage[] = {
f15eb531
NK		 2614 "perf trace [<options>] [<command>]",
2615 "perf trace [<options>] -- <command> [<options>]",
5e2485b1
DA		 2616 "perf trace record [<options>] [<command>]",
2617 "perf trace record [<options>] -- <command> [<options>]",
514f1c67
ACM		 2618 NULL
2619 };
2620 struct trace trace = {
c522739d
ACM		 2621 .audit = {
2622 .machine = audit_detect_machine(),
2623 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2624 },
514f1c67
ACM		 2625 .syscalls = {
2626 . max = -1,
2627 },
2628 .opts = {
2629 .target = {
2630 .uid = UINT_MAX,
2631 .uses_mmap = true,
2632 },
2633 .user_freq = UINT_MAX,
2634 .user_interval = ULLONG_MAX,
509051ea 2635 .no_buffering = true,
38d5447d 2636 .mmap_pages = UINT_MAX,
514f1c67 2637 },
c24ff998 2638 .output = stdout,
50c95cbd 2639 .show_comm = true,
e281a960 2640 .trace_syscalls = true,
514f1c67 2641 };
c24ff998 2642 const char *output_name = NULL;
2ae3a312 2643 const char *ev_qualifier_str = NULL;
514f1c67 2644 const struct option trace_options[] = {
14a052df
ACM		 2645 OPT_CALLBACK(0, "event", &trace.evlist, "event",
2646 "event selector. use 'perf list' to list available events",
2647 parse_events_option),
50c95cbd
ACM		 2648 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2649 "show the thread COMM next to its id"),
c522739d 2650 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2ae3a312
ACM		 2651 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2652 "list of events to trace"),
c24ff998 2653 OPT_STRING('o', "output", &output_name, "file", "output file name"),
6810fc91 2654 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
514f1c67
ACM		 2655 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2656 "trace events on existing process id"),
ac9be8ee 2657 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
514f1c67 2658 "trace events on existing thread id"),
f078c385
ACM		 2659 OPT_CALLBACK(0, "filter-pids", &trace, "float",
2660 "show only events with duration > N.M ms", trace__set_filter_pids),
ac9be8ee 2661 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
514f1c67 2662 "system-wide collection from all CPUs"),
ac9be8ee 2663 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
514f1c67 2664 "list of cpus to monitor"),
6810fc91 2665 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
514f1c67 2666 "child tasks do not inherit counters"),
994a1f78
JO		 2667 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2668 "number of mmap data pages",
2669 perf_evlist__parse_mmap_pages),
ac9be8ee 2670 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
514f1c67 2671 "user to profile"),
ae9ed035
ACM		 2672 OPT_CALLBACK(0, "duration", &trace, "float",
2673 "show only events with duration > N.M ms",
2674 trace__set_duration),
1302d88e 2675 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
7c304ee0 2676 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
4bb09192
DA		 2677 OPT_BOOLEAN('T', "time", &trace.full_time,
2678 "Show full timestamp, not time relative to first start"),
fd2eabaf
DA		 2679 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2680 "Show only syscall summary with statistics"),
2681 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2682 "Show all syscalls and summary with statistics"),
598d02c5
SF		 2683 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2684 "Trace pagefaults", parse_pagefaults, "maj"),
e281a960 2685 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
514f1c67
ACM		 2686 OPT_END()
2687 };
6fdd9cb7 2688 const char * const trace_subcommands[] = { "record", NULL };
514f1c67 2689 int err;
32caf0d1 2690 char bf[BUFSIZ];
514f1c67 2691
4d08cb80
ACM		 2692 signal(SIGSEGV, sighandler_dump_stack);
2693 signal(SIGFPE, sighandler_dump_stack);
2694
14a052df
ACM		 2695 trace.evlist = perf_evlist__new();
2696 if (trace.evlist == NULL)
2697 return -ENOMEM;
2698
2699 if (trace.evlist == NULL) {
2700 pr_err("Not enough memory to run!\n");
2701 goto out;
2702 }
2703
6fdd9cb7
YS		 2704 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
2705 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
fd2eabaf 2706
598d02c5
SF		 2707 if (trace.trace_pgfaults) {
2708 trace.opts.sample_address = true;
2709 trace.opts.sample_time = true;
2710 }
2711
14a052df
ACM		 2712 if (trace.evlist->nr_entries > 0)
2713 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
2714
1e28fe0a
SF		 2715 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2716 return trace__record(&trace, argc-1, &argv[1]);
2717
2718 /* summary_only implies summary option, but don't overwrite summary if set */
2719 if (trace.summary_only)
2720 trace.summary = trace.summary_only;
2721
726f3234
ACM		 2722 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
2723 trace.evlist->nr_entries == 0 /* Was --events used? */) {
e281a960
SF		 2724 pr_err("Please specify something to trace.\n");
2725 return -1;
2726 }
2727
c24ff998
ACM		 2728 if (output_name != NULL) {
2729 err = trace__open_output(&trace, output_name);
2730 if (err < 0) {
2731 perror("failed to create output file");
2732 goto out;
2733 }
2734 }
2735
2ae3a312 2736 if (ev_qualifier_str != NULL) {
b059efdf
ACM		 2737 const char *s = ev_qualifier_str;
2738
2739 trace.not_ev_qualifier = *s == '!';
2740 if (trace.not_ev_qualifier)
2741 ++s;
2742 trace.ev_qualifier = strlist__new(true, s);
2ae3a312 2743 if (trace.ev_qualifier == NULL) {
c24ff998
ACM		 2744 fputs("Not enough memory to parse event qualifier",
2745 trace.output);
2746 err = -ENOMEM;
2747 goto out_close;
2ae3a312
ACM		 2748 }
2749 }
2750
602ad878 2751 err = target__validate(&trace.opts.target);
32caf0d1 2752 if (err) {
602ad878 2753 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2754 fprintf(trace.output, "%s", bf);
2755 goto out_close;
32caf0d1
NK		 2756 }
2757
602ad878 2758 err = target__parse_uid(&trace.opts.target);
514f1c67 2759 if (err) {
602ad878 2760 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2761 fprintf(trace.output, "%s", bf);
2762 goto out_close;
514f1c67
ACM		 2763 }
2764
602ad878 2765 if (!argc && target__none(&trace.opts.target))
ee76120e
NK		 2766 trace.opts.target.system_wide = true;
2767
6810fc91
DA		 2768 if (input_name)
2769 err = trace__replay(&trace);
2770 else
2771 err = trace__run(&trace, argc, argv);
1302d88e 2772
c24ff998
ACM		 2773out_close:
2774 if (output_name != NULL)
2775 fclose(trace.output);
2776out:
1302d88e 2777 return err;
514f1c67 2778}
ubuntu-bionic-kernel mirror