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