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