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