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