4 * Builtin 'trace' command:
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.
10 * Copyright (C) 2012, 2013, 2014, 2015 Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
12 * Initially based on the 'trace' prototype by Thomas Gleixner:
14 * http://lwn.net/Articles/415728/ ("Announcing a new utility: 'trace'")
16 * Released under the GPL v2. (and only v2, not any later version)
19 #include <traceevent/event-parse.h>
20 #include <api/fs/tracing_path.h>
22 #include "util/color.h"
23 #include "util/debug.h"
24 #include "util/evlist.h"
25 #include "util/exec_cmd.h"
26 #include "util/machine.h"
27 #include "util/session.h"
28 #include "util/thread.h"
29 #include "util/parse-options.h"
30 #include "util/strlist.h"
31 #include "util/intlist.h"
32 #include "util/thread_map.h"
33 #include "util/stat.h"
34 #include "trace-event.h"
35 #include "util/parse-events.h"
40 #include <linux/futex.h>
41 #include <linux/err.h>
43 /* For older distros: */
45 # define MAP_STACK 0x20000
49 # define MADV_HWPOISON 100
53 #ifndef MADV_MERGEABLE
54 # define MADV_MERGEABLE 12
57 #ifndef MADV_UNMERGEABLE
58 # define MADV_UNMERGEABLE 13
62 # define EFD_SEMAPHORE 1
66 # define EFD_NONBLOCK 00004000
70 # define EFD_CLOEXEC 02000000
74 # define O_CLOEXEC 02000000
82 # define SOCK_CLOEXEC 02000000
86 # define SOCK_NONBLOCK 00004000
89 #ifndef MSG_CMSG_CLOEXEC
90 # define MSG_CMSG_CLOEXEC 0x40000000
93 #ifndef PERF_FLAG_FD_NO_GROUP
94 # define PERF_FLAG_FD_NO_GROUP (1UL << 0)
97 #ifndef PERF_FLAG_FD_OUTPUT
98 # define PERF_FLAG_FD_OUTPUT (1UL << 1)
101 #ifndef PERF_FLAG_PID_CGROUP
102 # define PERF_FLAG_PID_CGROUP (1UL << 2) /* pid=cgroup id, per-cpu mode only */
105 #ifndef PERF_FLAG_FD_CLOEXEC
106 # define PERF_FLAG_FD_CLOEXEC (1UL << 3) /* O_CLOEXEC */
113 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
114 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
118 #define TP_UINT_FIELD(bits) \
119 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
122 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
131 #define TP_UINT_FIELD__SWAPPED(bits) \
132 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
135 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
136 return bswap_##bits(value);\
139 TP_UINT_FIELD__SWAPPED(16);
140 TP_UINT_FIELD__SWAPPED(32);
141 TP_UINT_FIELD__SWAPPED(64);
143 static int tp_field__init_uint(struct tp_field *field,
144 struct format_field *format_field,
147 field->offset = format_field->offset;
149 switch (format_field->size) {
151 field->integer = tp_field__u8;
154 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
157 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
160 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
169 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
171 return sample->raw_data + field->offset;
174 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
176 field->offset = format_field->offset;
177 field->pointer = tp_field__ptr;
184 struct tp_field args, ret;
188 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
189 struct tp_field *field,
192 struct format_field *format_field = perf_evsel__field(evsel, name);
194 if (format_field == NULL)
197 return tp_field__init_uint(field, format_field, evsel->needs_swap);
200 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
201 ({ struct syscall_tp *sc = evsel->priv;\
202 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
204 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
205 struct tp_field *field,
208 struct format_field *format_field = perf_evsel__field(evsel, name);
210 if (format_field == NULL)
213 return tp_field__init_ptr(field, format_field);
216 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
217 ({ struct syscall_tp *sc = evsel->priv;\
218 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
220 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
223 perf_evsel__delete(evsel);
226 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
228 evsel->priv = malloc(sizeof(struct syscall_tp));
229 if (evsel->priv != NULL) {
230 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
233 evsel->handler = handler;
244 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
246 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
248 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
250 evsel = perf_evsel__newtp("syscalls", direction);
255 if (perf_evsel__init_syscall_tp(evsel, handler))
261 perf_evsel__delete_priv(evsel);
265 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
266 ({ struct syscall_tp *fields = evsel->priv; \
267 fields->name.integer(&fields->name, sample); })
269 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
270 ({ struct syscall_tp *fields = evsel->priv; \
271 fields->name.pointer(&fields->name, sample); })
275 struct thread *thread;
285 const char **entries;
288 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
289 .nr_entries = ARRAY_SIZE(array), \
293 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
295 .nr_entries = ARRAY_SIZE(array), \
299 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
301 struct syscall_arg *arg)
303 struct strarray *sa = arg->parm;
304 int idx = arg->val - sa->offset;
306 if (idx < 0 || idx >= sa->nr_entries)
307 return scnprintf(bf, size, intfmt, arg->val);
309 return scnprintf(bf, size, "%s", sa->entries[idx]);
312 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
313 struct syscall_arg *arg)
315 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
318 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
320 #if defined(__i386__) || defined(__x86_64__)
322 * FIXME: Make this available to all arches as soon as the ioctl beautifier
323 * gets rewritten to support all arches.
325 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
326 struct syscall_arg *arg)
328 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
331 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
332 #endif /* defined(__i386__) || defined(__x86_64__) */
334 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
335 struct syscall_arg *arg);
337 #define SCA_FD syscall_arg__scnprintf_fd
339 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
340 struct syscall_arg *arg)
345 return scnprintf(bf, size, "CWD");
347 return syscall_arg__scnprintf_fd(bf, size, arg);
350 #define SCA_FDAT syscall_arg__scnprintf_fd_at
352 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
353 struct syscall_arg *arg);
355 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
357 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
358 struct syscall_arg *arg)
360 return scnprintf(bf, size, "%#lx", arg->val);
363 #define SCA_HEX syscall_arg__scnprintf_hex
365 static size_t syscall_arg__scnprintf_int(char *bf, size_t size,
366 struct syscall_arg *arg)
368 return scnprintf(bf, size, "%d", arg->val);
371 #define SCA_INT syscall_arg__scnprintf_int
373 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
374 struct syscall_arg *arg)
376 int printed = 0, prot = arg->val;
378 if (prot == PROT_NONE)
379 return scnprintf(bf, size, "NONE");
380 #define P_MMAP_PROT(n) \
381 if (prot & PROT_##n) { \
382 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
392 P_MMAP_PROT(GROWSDOWN);
393 P_MMAP_PROT(GROWSUP);
397 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
402 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
404 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
405 struct syscall_arg *arg)
407 int printed = 0, flags = arg->val;
409 #define P_MMAP_FLAG(n) \
410 if (flags & MAP_##n) { \
411 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
416 P_MMAP_FLAG(PRIVATE);
420 P_MMAP_FLAG(ANONYMOUS);
421 P_MMAP_FLAG(DENYWRITE);
422 P_MMAP_FLAG(EXECUTABLE);
425 P_MMAP_FLAG(GROWSDOWN);
427 P_MMAP_FLAG(HUGETLB);
430 P_MMAP_FLAG(NONBLOCK);
431 P_MMAP_FLAG(NORESERVE);
432 P_MMAP_FLAG(POPULATE);
434 #ifdef MAP_UNINITIALIZED
435 P_MMAP_FLAG(UNINITIALIZED);
440 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
445 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
447 static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
448 struct syscall_arg *arg)
450 int printed = 0, flags = arg->val;
452 #define P_MREMAP_FLAG(n) \
453 if (flags & MREMAP_##n) { \
454 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
455 flags &= ~MREMAP_##n; \
458 P_MREMAP_FLAG(MAYMOVE);
460 P_MREMAP_FLAG(FIXED);
465 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
470 #define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
472 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
473 struct syscall_arg *arg)
475 int behavior = arg->val;
478 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
481 P_MADV_BHV(SEQUENTIAL);
482 P_MADV_BHV(WILLNEED);
483 P_MADV_BHV(DONTNEED);
485 P_MADV_BHV(DONTFORK);
487 P_MADV_BHV(HWPOISON);
488 #ifdef MADV_SOFT_OFFLINE
489 P_MADV_BHV(SOFT_OFFLINE);
491 P_MADV_BHV(MERGEABLE);
492 P_MADV_BHV(UNMERGEABLE);
494 P_MADV_BHV(HUGEPAGE);
496 #ifdef MADV_NOHUGEPAGE
497 P_MADV_BHV(NOHUGEPAGE);
500 P_MADV_BHV(DONTDUMP);
509 return scnprintf(bf, size, "%#x", behavior);
512 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
514 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
515 struct syscall_arg *arg)
517 int printed = 0, op = arg->val;
520 return scnprintf(bf, size, "NONE");
522 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
523 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
538 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
543 #define SCA_FLOCK syscall_arg__scnprintf_flock
545 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
547 enum syscall_futex_args {
548 SCF_UADDR = (1 << 0),
551 SCF_TIMEOUT = (1 << 3),
552 SCF_UADDR2 = (1 << 4),
556 int cmd = op & FUTEX_CMD_MASK;
560 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
561 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
562 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
563 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
564 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
565 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
566 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
567 P_FUTEX_OP(WAKE_OP); break;
568 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
569 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
570 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
571 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
572 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
573 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
574 default: printed = scnprintf(bf, size, "%#x", cmd); break;
577 if (op & FUTEX_PRIVATE_FLAG)
578 printed += scnprintf(bf + printed, size - printed, "|PRIV");
580 if (op & FUTEX_CLOCK_REALTIME)
581 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
586 #define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
588 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
589 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
591 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
592 static DEFINE_STRARRAY(itimers);
594 static const char *keyctl_options[] = {
595 "GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
596 "SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
597 "INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
598 "ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
599 "INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
601 static DEFINE_STRARRAY(keyctl_options);
603 static const char *whences[] = { "SET", "CUR", "END",
611 static DEFINE_STRARRAY(whences);
613 static const char *fcntl_cmds[] = {
614 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
615 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
616 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
619 static DEFINE_STRARRAY(fcntl_cmds);
621 static const char *rlimit_resources[] = {
622 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
623 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
626 static DEFINE_STRARRAY(rlimit_resources);
628 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
629 static DEFINE_STRARRAY(sighow);
631 static const char *clockid[] = {
632 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
633 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
634 "REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
636 static DEFINE_STRARRAY(clockid);
638 static const char *socket_families[] = {
639 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
640 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
641 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
642 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
643 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
644 "ALG", "NFC", "VSOCK",
646 static DEFINE_STRARRAY(socket_families);
648 #ifndef SOCK_TYPE_MASK
649 #define SOCK_TYPE_MASK 0xf
652 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
653 struct syscall_arg *arg)
657 flags = type & ~SOCK_TYPE_MASK;
659 type &= SOCK_TYPE_MASK;
661 * Can't use a strarray, MIPS may override for ABI reasons.
664 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
669 P_SK_TYPE(SEQPACKET);
674 printed = scnprintf(bf, size, "%#x", type);
677 #define P_SK_FLAG(n) \
678 if (flags & SOCK_##n) { \
679 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
680 flags &= ~SOCK_##n; \
688 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
693 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
696 #define MSG_PROBE 0x10
698 #ifndef MSG_WAITFORONE
699 #define MSG_WAITFORONE 0x10000
701 #ifndef MSG_SENDPAGE_NOTLAST
702 #define MSG_SENDPAGE_NOTLAST 0x20000
705 #define MSG_FASTOPEN 0x20000000
708 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
709 struct syscall_arg *arg)
711 int printed = 0, flags = arg->val;
714 return scnprintf(bf, size, "NONE");
715 #define P_MSG_FLAG(n) \
716 if (flags & MSG_##n) { \
717 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
723 P_MSG_FLAG(DONTROUTE);
728 P_MSG_FLAG(DONTWAIT);
735 P_MSG_FLAG(ERRQUEUE);
736 P_MSG_FLAG(NOSIGNAL);
738 P_MSG_FLAG(WAITFORONE);
739 P_MSG_FLAG(SENDPAGE_NOTLAST);
740 P_MSG_FLAG(FASTOPEN);
741 P_MSG_FLAG(CMSG_CLOEXEC);
745 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
750 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
752 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
753 struct syscall_arg *arg)
758 if (mode == F_OK) /* 0 */
759 return scnprintf(bf, size, "F");
761 if (mode & n##_OK) { \
762 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
772 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
777 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
779 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
780 struct syscall_arg *arg);
782 #define SCA_FILENAME syscall_arg__scnprintf_filename
784 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
785 struct syscall_arg *arg)
787 int printed = 0, flags = arg->val;
789 if (!(flags & O_CREAT))
790 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
793 return scnprintf(bf, size, "RDONLY");
795 if (flags & O_##n) { \
796 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
820 if ((flags & O_SYNC) == O_SYNC)
821 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
833 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
838 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
840 static size_t syscall_arg__scnprintf_perf_flags(char *bf, size_t size,
841 struct syscall_arg *arg)
843 int printed = 0, flags = arg->val;
849 if (flags & PERF_FLAG_##n) { \
850 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
851 flags &= ~PERF_FLAG_##n; \
861 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
866 #define SCA_PERF_FLAGS syscall_arg__scnprintf_perf_flags
868 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
869 struct syscall_arg *arg)
871 int printed = 0, flags = arg->val;
874 return scnprintf(bf, size, "NONE");
876 if (flags & EFD_##n) { \
877 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
887 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
892 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
894 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
895 struct syscall_arg *arg)
897 int printed = 0, flags = arg->val;
900 if (flags & O_##n) { \
901 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
910 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
915 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
917 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
922 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
965 return scnprintf(bf, size, "%#x", sig);
968 #define SCA_SIGNUM syscall_arg__scnprintf_signum
970 #if defined(__i386__) || defined(__x86_64__)
972 * FIXME: Make this available to all arches.
974 #define TCGETS 0x5401
976 static const char *tioctls[] = {
977 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
978 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
979 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
980 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
981 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
982 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
983 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
984 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
985 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
986 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
987 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
988 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
989 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
990 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
991 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
994 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
995 #endif /* defined(__i386__) || defined(__x86_64__) */
997 #define STRARRAY(arg, name, array) \
998 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
999 .arg_parm = { [arg] = &strarray__##array, }
1001 static struct syscall_fmt {
1004 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
1009 } syscall_fmts[] = {
1010 { .name = "access", .errmsg = true,
1011 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */
1012 [1] = SCA_ACCMODE, /* mode */ }, },
1013 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
1014 { .name = "brk", .hexret = true,
1015 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
1016 { .name = "chdir", .errmsg = true,
1017 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1018 { .name = "chmod", .errmsg = true,
1019 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1020 { .name = "chroot", .errmsg = true,
1021 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1022 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
1023 { .name = "close", .errmsg = true,
1024 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
1025 { .name = "connect", .errmsg = true, },
1026 { .name = "creat", .errmsg = true,
1027 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1028 { .name = "dup", .errmsg = true,
1029 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1030 { .name = "dup2", .errmsg = true,
1031 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1032 { .name = "dup3", .errmsg = true,
1033 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1034 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
1035 { .name = "eventfd2", .errmsg = true,
1036 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
1037 { .name = "faccessat", .errmsg = true,
1038 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1039 [1] = SCA_FILENAME, /* filename */ }, },
1040 { .name = "fadvise64", .errmsg = true,
1041 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1042 { .name = "fallocate", .errmsg = true,
1043 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1044 { .name = "fchdir", .errmsg = true,
1045 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1046 { .name = "fchmod", .errmsg = true,
1047 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1048 { .name = "fchmodat", .errmsg = true,
1049 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1050 [1] = SCA_FILENAME, /* filename */ }, },
1051 { .name = "fchown", .errmsg = true,
1052 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1053 { .name = "fchownat", .errmsg = true,
1054 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1055 [1] = SCA_FILENAME, /* filename */ }, },
1056 { .name = "fcntl", .errmsg = true,
1057 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1058 [1] = SCA_STRARRAY, /* cmd */ },
1059 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
1060 { .name = "fdatasync", .errmsg = true,
1061 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1062 { .name = "flock", .errmsg = true,
1063 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1064 [1] = SCA_FLOCK, /* cmd */ }, },
1065 { .name = "fsetxattr", .errmsg = true,
1066 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1067 { .name = "fstat", .errmsg = true, .alias = "newfstat",
1068 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1069 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
1070 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1071 [1] = SCA_FILENAME, /* filename */ }, },
1072 { .name = "fstatfs", .errmsg = true,
1073 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1074 { .name = "fsync", .errmsg = true,
1075 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1076 { .name = "ftruncate", .errmsg = true,
1077 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1078 { .name = "futex", .errmsg = true,
1079 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
1080 { .name = "futimesat", .errmsg = true,
1081 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1082 [1] = SCA_FILENAME, /* filename */ }, },
1083 { .name = "getdents", .errmsg = true,
1084 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1085 { .name = "getdents64", .errmsg = true,
1086 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1087 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1088 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1089 { .name = "getxattr", .errmsg = true,
1090 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1091 { .name = "inotify_add_watch", .errmsg = true,
1092 .arg_scnprintf = { [1] = SCA_FILENAME, /* pathname */ }, },
1093 { .name = "ioctl", .errmsg = true,
1094 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1095 #if defined(__i386__) || defined(__x86_64__)
1097 * FIXME: Make this available to all arches.
1099 [1] = SCA_STRHEXARRAY, /* cmd */
1100 [2] = SCA_HEX, /* arg */ },
1101 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
1103 [2] = SCA_HEX, /* arg */ }, },
1105 { .name = "keyctl", .errmsg = true, STRARRAY(0, option, keyctl_options), },
1106 { .name = "kill", .errmsg = true,
1107 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1108 { .name = "lchown", .errmsg = true,
1109 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1110 { .name = "lgetxattr", .errmsg = true,
1111 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1112 { .name = "linkat", .errmsg = true,
1113 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1114 { .name = "listxattr", .errmsg = true,
1115 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1116 { .name = "llistxattr", .errmsg = true,
1117 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1118 { .name = "lremovexattr", .errmsg = true,
1119 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1120 { .name = "lseek", .errmsg = true,
1121 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1122 [2] = SCA_STRARRAY, /* whence */ },
1123 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
1124 { .name = "lsetxattr", .errmsg = true,
1125 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1126 { .name = "lstat", .errmsg = true, .alias = "newlstat",
1127 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1128 { .name = "lsxattr", .errmsg = true,
1129 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1130 { .name = "madvise", .errmsg = true,
1131 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1132 [2] = SCA_MADV_BHV, /* behavior */ }, },
1133 { .name = "mkdir", .errmsg = true,
1134 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1135 { .name = "mkdirat", .errmsg = true,
1136 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1137 [1] = SCA_FILENAME, /* pathname */ }, },
1138 { .name = "mknod", .errmsg = true,
1139 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1140 { .name = "mknodat", .errmsg = true,
1141 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1142 [1] = SCA_FILENAME, /* filename */ }, },
1143 { .name = "mlock", .errmsg = true,
1144 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1145 { .name = "mlockall", .errmsg = true,
1146 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1147 { .name = "mmap", .hexret = true,
1148 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1149 [2] = SCA_MMAP_PROT, /* prot */
1150 [3] = SCA_MMAP_FLAGS, /* flags */
1151 [4] = SCA_FD, /* fd */ }, },
1152 { .name = "mprotect", .errmsg = true,
1153 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1154 [2] = SCA_MMAP_PROT, /* prot */ }, },
1155 { .name = "mq_unlink", .errmsg = true,
1156 .arg_scnprintf = { [0] = SCA_FILENAME, /* u_name */ }, },
1157 { .name = "mremap", .hexret = true,
1158 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1159 [3] = SCA_MREMAP_FLAGS, /* flags */
1160 [4] = SCA_HEX, /* new_addr */ }, },
1161 { .name = "munlock", .errmsg = true,
1162 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1163 { .name = "munmap", .errmsg = true,
1164 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1165 { .name = "name_to_handle_at", .errmsg = true,
1166 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1167 { .name = "newfstatat", .errmsg = true,
1168 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1169 [1] = SCA_FILENAME, /* filename */ }, },
1170 { .name = "open", .errmsg = true,
1171 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */
1172 [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1173 { .name = "open_by_handle_at", .errmsg = true,
1174 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1175 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1176 { .name = "openat", .errmsg = true,
1177 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1178 [1] = SCA_FILENAME, /* filename */
1179 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1180 { .name = "perf_event_open", .errmsg = true,
1181 .arg_scnprintf = { [1] = SCA_INT, /* pid */
1182 [2] = SCA_INT, /* cpu */
1183 [3] = SCA_FD, /* group_fd */
1184 [4] = SCA_PERF_FLAGS, /* flags */ }, },
1185 { .name = "pipe2", .errmsg = true,
1186 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1187 { .name = "poll", .errmsg = true, .timeout = true, },
1188 { .name = "ppoll", .errmsg = true, .timeout = true, },
1189 { .name = "pread", .errmsg = true, .alias = "pread64",
1190 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1191 { .name = "preadv", .errmsg = true, .alias = "pread",
1192 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1193 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1194 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
1195 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1196 { .name = "pwritev", .errmsg = true,
1197 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1198 { .name = "read", .errmsg = true,
1199 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1200 { .name = "readlink", .errmsg = true,
1201 .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
1202 { .name = "readlinkat", .errmsg = true,
1203 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1204 [1] = SCA_FILENAME, /* pathname */ }, },
1205 { .name = "readv", .errmsg = true,
1206 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1207 { .name = "recvfrom", .errmsg = true,
1208 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1209 [3] = SCA_MSG_FLAGS, /* flags */ }, },
1210 { .name = "recvmmsg", .errmsg = true,
1211 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1212 [3] = SCA_MSG_FLAGS, /* flags */ }, },
1213 { .name = "recvmsg", .errmsg = true,
1214 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1215 [2] = SCA_MSG_FLAGS, /* flags */ }, },
1216 { .name = "removexattr", .errmsg = true,
1217 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1218 { .name = "renameat", .errmsg = true,
1219 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1220 { .name = "rmdir", .errmsg = true,
1221 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1222 { .name = "rt_sigaction", .errmsg = true,
1223 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1224 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
1225 { .name = "rt_sigqueueinfo", .errmsg = true,
1226 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1227 { .name = "rt_tgsigqueueinfo", .errmsg = true,
1228 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1229 { .name = "select", .errmsg = true, .timeout = true, },
1230 { .name = "sendmmsg", .errmsg = true,
1231 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1232 [3] = SCA_MSG_FLAGS, /* flags */ }, },
1233 { .name = "sendmsg", .errmsg = true,
1234 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1235 [2] = SCA_MSG_FLAGS, /* flags */ }, },
1236 { .name = "sendto", .errmsg = true,
1237 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1238 [3] = SCA_MSG_FLAGS, /* flags */ }, },
1239 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1240 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1241 { .name = "setxattr", .errmsg = true,
1242 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1243 { .name = "shutdown", .errmsg = true,
1244 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1245 { .name = "socket", .errmsg = true,
1246 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1247 [1] = SCA_SK_TYPE, /* type */ },
1248 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1249 { .name = "socketpair", .errmsg = true,
1250 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1251 [1] = SCA_SK_TYPE, /* type */ },
1252 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1253 { .name = "stat", .errmsg = true, .alias = "newstat",
1254 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1255 { .name = "statfs", .errmsg = true,
1256 .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1257 { .name = "swapoff", .errmsg = true,
1258 .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
1259 { .name = "swapon", .errmsg = true,
1260 .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
1261 { .name = "symlinkat", .errmsg = true,
1262 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1263 { .name = "tgkill", .errmsg = true,
1264 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1265 { .name = "tkill", .errmsg = true,
1266 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1267 { .name = "truncate", .errmsg = true,
1268 .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
1269 { .name = "uname", .errmsg = true, .alias = "newuname", },
1270 { .name = "unlinkat", .errmsg = true,
1271 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1272 [1] = SCA_FILENAME, /* pathname */ }, },
1273 { .name = "utime", .errmsg = true,
1274 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1275 { .name = "utimensat", .errmsg = true,
1276 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */
1277 [1] = SCA_FILENAME, /* filename */ }, },
1278 { .name = "utimes", .errmsg = true,
1279 .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1280 { .name = "vmsplice", .errmsg = true,
1281 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1282 { .name = "write", .errmsg = true,
1283 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1284 { .name = "writev", .errmsg = true,
1285 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1288 static int syscall_fmt__cmp(const void *name, const void *fmtp)
1290 const struct syscall_fmt *fmt = fmtp;
1291 return strcmp(name, fmt->name);
1294 static struct syscall_fmt *syscall_fmt__find(const char *name)
1296 const int nmemb = ARRAY_SIZE(syscall_fmts);
1297 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1301 struct event_format *tp_format;
1303 struct format_field *args;
1306 struct syscall_fmt *fmt;
1307 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1311 static size_t fprintf_duration(unsigned long t, FILE *fp)
1313 double duration = (double)t / NSEC_PER_MSEC;
1314 size_t printed = fprintf(fp, "(");
1316 if (duration >= 1.0)
1317 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1318 else if (duration >= 0.01)
1319 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1321 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1322 return printed + fprintf(fp, "): ");
1326 * filename.ptr: The filename char pointer that will be vfs_getname'd
1327 * filename.entry_str_pos: Where to insert the string translated from
1328 * filename.ptr by the vfs_getname tracepoint/kprobe.
1330 struct thread_trace {
1334 unsigned long nr_events;
1335 unsigned long pfmaj, pfmin;
1340 short int entry_str_pos;
1342 unsigned int namelen;
1350 struct intlist *syscall_stats;
1353 static struct thread_trace *thread_trace__new(void)
1355 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1358 ttrace->paths.max = -1;
1360 ttrace->syscall_stats = intlist__new(NULL);
1365 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1367 struct thread_trace *ttrace;
1372 if (thread__priv(thread) == NULL)
1373 thread__set_priv(thread, thread_trace__new());
1375 if (thread__priv(thread) == NULL)
1378 ttrace = thread__priv(thread);
1379 ++ttrace->nr_events;
1383 color_fprintf(fp, PERF_COLOR_RED,
1384 "WARNING: not enough memory, dropping samples!\n");
1388 #define TRACE_PFMAJ (1 << 0)
1389 #define TRACE_PFMIN (1 << 1)
1391 static const size_t trace__entry_str_size = 2048;
1394 struct perf_tool tool;
1401 struct syscall *table;
1403 struct perf_evsel *sys_enter,
1407 struct record_opts opts;
1408 struct perf_evlist *evlist;
1409 struct machine *host;
1410 struct thread *current;
1413 unsigned long nr_events;
1414 struct strlist *ev_qualifier;
1419 struct intlist *tid_list;
1420 struct intlist *pid_list;
1425 double duration_filter;
1431 bool not_ev_qualifier;
1435 bool multiple_threads;
1439 bool show_tool_stats;
1440 bool trace_syscalls;
1446 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1448 struct thread_trace *ttrace = thread__priv(thread);
1450 if (fd > ttrace->paths.max) {
1451 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1456 if (ttrace->paths.max != -1) {
1457 memset(npath + ttrace->paths.max + 1, 0,
1458 (fd - ttrace->paths.max) * sizeof(char *));
1460 memset(npath, 0, (fd + 1) * sizeof(char *));
1463 ttrace->paths.table = npath;
1464 ttrace->paths.max = fd;
1467 ttrace->paths.table[fd] = strdup(pathname);
1469 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1472 static int thread__read_fd_path(struct thread *thread, int fd)
1474 char linkname[PATH_MAX], pathname[PATH_MAX];
1478 if (thread->pid_ == thread->tid) {
1479 scnprintf(linkname, sizeof(linkname),
1480 "/proc/%d/fd/%d", thread->pid_, fd);
1482 scnprintf(linkname, sizeof(linkname),
1483 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1486 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1489 ret = readlink(linkname, pathname, sizeof(pathname));
1491 if (ret < 0 || ret > st.st_size)
1494 pathname[ret] = '\0';
1495 return trace__set_fd_pathname(thread, fd, pathname);
1498 static const char *thread__fd_path(struct thread *thread, int fd,
1499 struct trace *trace)
1501 struct thread_trace *ttrace = thread__priv(thread);
1509 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1512 ++trace->stats.proc_getname;
1513 if (thread__read_fd_path(thread, fd))
1517 return ttrace->paths.table[fd];
1520 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1521 struct syscall_arg *arg)
1524 size_t printed = scnprintf(bf, size, "%d", fd);
1525 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1528 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1533 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1534 struct syscall_arg *arg)
1537 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1538 struct thread_trace *ttrace = thread__priv(arg->thread);
1540 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1541 zfree(&ttrace->paths.table[fd]);
1546 static void thread__set_filename_pos(struct thread *thread, const char *bf,
1549 struct thread_trace *ttrace = thread__priv(thread);
1551 ttrace->filename.ptr = ptr;
1552 ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1555 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1556 struct syscall_arg *arg)
1558 unsigned long ptr = arg->val;
1560 if (!arg->trace->vfs_getname)
1561 return scnprintf(bf, size, "%#x", ptr);
1563 thread__set_filename_pos(arg->thread, bf, ptr);
1567 static bool trace__filter_duration(struct trace *trace, double t)
1569 return t < (trace->duration_filter * NSEC_PER_MSEC);
1572 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1574 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1576 return fprintf(fp, "%10.3f ", ts);
1579 static bool done = false;
1580 static bool interrupted = false;
1582 static void sig_handler(int sig)
1585 interrupted = sig == SIGINT;
1588 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1589 u64 duration, u64 tstamp, FILE *fp)
1591 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1592 printed += fprintf_duration(duration, fp);
1594 if (trace->multiple_threads) {
1595 if (trace->show_comm)
1596 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1597 printed += fprintf(fp, "%d ", thread->tid);
1603 static int trace__process_event(struct trace *trace, struct machine *machine,
1604 union perf_event *event, struct perf_sample *sample)
1608 switch (event->header.type) {
1609 case PERF_RECORD_LOST:
1610 color_fprintf(trace->output, PERF_COLOR_RED,
1611 "LOST %" PRIu64 " events!\n", event->lost.lost);
1612 ret = machine__process_lost_event(machine, event, sample);
1614 ret = machine__process_event(machine, event, sample);
1621 static int trace__tool_process(struct perf_tool *tool,
1622 union perf_event *event,
1623 struct perf_sample *sample,
1624 struct machine *machine)
1626 struct trace *trace = container_of(tool, struct trace, tool);
1627 return trace__process_event(trace, machine, event, sample);
1630 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1632 int err = symbol__init(NULL);
1637 trace->host = machine__new_host();
1638 if (trace->host == NULL)
1641 if (trace_event__register_resolver(trace->host, machine__resolve_kernel_addr) < 0)
1644 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1645 evlist->threads, trace__tool_process, false,
1646 trace->opts.proc_map_timeout);
1653 static int syscall__set_arg_fmts(struct syscall *sc)
1655 struct format_field *field;
1658 sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
1659 if (sc->arg_scnprintf == NULL)
1663 sc->arg_parm = sc->fmt->arg_parm;
1665 for (field = sc->args; field; field = field->next) {
1666 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1667 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1668 else if (field->flags & FIELD_IS_POINTER)
1669 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1676 static int trace__read_syscall_info(struct trace *trace, int id)
1680 const char *name = audit_syscall_to_name(id, trace->audit.machine);
1685 if (id > trace->syscalls.max) {
1686 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1688 if (nsyscalls == NULL)
1691 if (trace->syscalls.max != -1) {
1692 memset(nsyscalls + trace->syscalls.max + 1, 0,
1693 (id - trace->syscalls.max) * sizeof(*sc));
1695 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1698 trace->syscalls.table = nsyscalls;
1699 trace->syscalls.max = id;
1702 sc = trace->syscalls.table + id;
1705 sc->fmt = syscall_fmt__find(sc->name);
1707 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1708 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1710 if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
1711 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1712 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1715 if (IS_ERR(sc->tp_format))
1718 sc->args = sc->tp_format->format.fields;
1719 sc->nr_args = sc->tp_format->format.nr_fields;
1720 /* drop nr field - not relevant here; does not exist on older kernels */
1721 if (sc->args && strcmp(sc->args->name, "nr") == 0) {
1722 sc->args = sc->args->next;
1726 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1728 return syscall__set_arg_fmts(sc);
1731 static int trace__validate_ev_qualifier(struct trace *trace)
1734 struct str_node *pos;
1736 trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1737 trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1738 sizeof(trace->ev_qualifier_ids.entries[0]));
1740 if (trace->ev_qualifier_ids.entries == NULL) {
1741 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1749 strlist__for_each(pos, trace->ev_qualifier) {
1750 const char *sc = pos->s;
1751 int id = audit_name_to_syscall(sc, trace->audit.machine);
1755 fputs("Error:\tInvalid syscall ", trace->output);
1758 fputs(", ", trace->output);
1761 fputs(sc, trace->output);
1764 trace->ev_qualifier_ids.entries[i++] = id;
1768 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1769 "\nHint:\tand: 'man syscalls'\n", trace->output);
1770 zfree(&trace->ev_qualifier_ids.entries);
1771 trace->ev_qualifier_ids.nr = 0;
1778 * args is to be interpreted as a series of longs but we need to handle
1779 * 8-byte unaligned accesses. args points to raw_data within the event
1780 * and raw_data is guaranteed to be 8-byte unaligned because it is
1781 * preceded by raw_size which is a u32. So we need to copy args to a temp
1782 * variable to read it. Most notably this avoids extended load instructions
1783 * on unaligned addresses
1786 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1787 unsigned char *args, struct trace *trace,
1788 struct thread *thread)
1794 if (sc->args != NULL) {
1795 struct format_field *field;
1797 struct syscall_arg arg = {
1804 for (field = sc->args; field;
1805 field = field->next, ++arg.idx, bit <<= 1) {
1809 /* special care for unaligned accesses */
1810 p = args + sizeof(unsigned long) * arg.idx;
1811 memcpy(&val, p, sizeof(val));
1814 * Suppress this argument if its value is zero and
1815 * and we don't have a string associated in an
1819 !(sc->arg_scnprintf &&
1820 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1821 sc->arg_parm[arg.idx]))
1824 printed += scnprintf(bf + printed, size - printed,
1825 "%s%s: ", printed ? ", " : "", field->name);
1826 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1829 arg.parm = sc->arg_parm[arg.idx];
1830 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1831 size - printed, &arg);
1833 printed += scnprintf(bf + printed, size - printed,
1841 /* special care for unaligned accesses */
1842 p = args + sizeof(unsigned long) * i;
1843 memcpy(&val, p, sizeof(val));
1844 printed += scnprintf(bf + printed, size - printed,
1846 printed ? ", " : "", i, val);
1854 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1855 union perf_event *event,
1856 struct perf_sample *sample);
1858 static struct syscall *trace__syscall_info(struct trace *trace,
1859 struct perf_evsel *evsel, int id)
1865 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1866 * before that, leaving at a higher verbosity level till that is
1867 * explained. Reproduced with plain ftrace with:
1869 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1870 * grep "NR -1 " /t/trace_pipe
1872 * After generating some load on the machine.
1876 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1877 id, perf_evsel__name(evsel), ++n);
1882 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1883 trace__read_syscall_info(trace, id))
1886 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1889 return &trace->syscalls.table[id];
1893 fprintf(trace->output, "Problems reading syscall %d", id);
1894 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1895 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1896 fputs(" information\n", trace->output);
1901 static void thread__update_stats(struct thread_trace *ttrace,
1902 int id, struct perf_sample *sample)
1904 struct int_node *inode;
1905 struct stats *stats;
1908 inode = intlist__findnew(ttrace->syscall_stats, id);
1912 stats = inode->priv;
1913 if (stats == NULL) {
1914 stats = malloc(sizeof(struct stats));
1918 inode->priv = stats;
1921 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1922 duration = sample->time - ttrace->entry_time;
1924 update_stats(stats, duration);
1927 static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1929 struct thread_trace *ttrace;
1933 if (trace->current == NULL)
1936 ttrace = thread__priv(trace->current);
1938 if (!ttrace->entry_pending)
1941 duration = sample->time - ttrace->entry_time;
1943 printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1944 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1945 ttrace->entry_pending = false;
1950 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1951 union perf_event *event __maybe_unused,
1952 struct perf_sample *sample)
1957 struct thread *thread;
1958 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1959 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1960 struct thread_trace *ttrace;
1965 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1966 ttrace = thread__trace(thread, trace->output);
1970 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1972 if (ttrace->entry_str == NULL) {
1973 ttrace->entry_str = malloc(trace__entry_str_size);
1974 if (!ttrace->entry_str)
1978 if (!trace->summary_only)
1979 trace__printf_interrupted_entry(trace, sample);
1981 ttrace->entry_time = sample->time;
1982 msg = ttrace->entry_str;
1983 printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
1985 printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
1986 args, trace, thread);
1989 if (!trace->duration_filter && !trace->summary_only) {
1990 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1991 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1994 ttrace->entry_pending = true;
1995 /* See trace__vfs_getname & trace__sys_exit */
1996 ttrace->filename.pending_open = false;
1999 if (trace->current != thread) {
2000 thread__put(trace->current);
2001 trace->current = thread__get(thread);
2005 thread__put(thread);
2009 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
2010 union perf_event *event __maybe_unused,
2011 struct perf_sample *sample)
2015 struct thread *thread;
2016 int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
2017 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2018 struct thread_trace *ttrace;
2023 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2024 ttrace = thread__trace(thread, trace->output);
2029 thread__update_stats(ttrace, id, sample);
2031 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
2033 if (id == trace->audit.open_id && ret >= 0 && ttrace->filename.pending_open) {
2034 trace__set_fd_pathname(thread, ret, ttrace->filename.name);
2035 ttrace->filename.pending_open = false;
2036 ++trace->stats.vfs_getname;
2039 ttrace->exit_time = sample->time;
2041 if (ttrace->entry_time) {
2042 duration = sample->time - ttrace->entry_time;
2043 if (trace__filter_duration(trace, duration))
2045 } else if (trace->duration_filter)
2048 if (trace->summary_only)
2051 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
2053 if (ttrace->entry_pending) {
2054 fprintf(trace->output, "%-70s", ttrace->entry_str);
2056 fprintf(trace->output, " ... [");
2057 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
2058 fprintf(trace->output, "]: %s()", sc->name);
2061 if (sc->fmt == NULL) {
2063 fprintf(trace->output, ") = %ld", ret);
2064 } else if (ret < 0 && sc->fmt->errmsg) {
2065 char bf[STRERR_BUFSIZE];
2066 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
2067 *e = audit_errno_to_name(-ret);
2069 fprintf(trace->output, ") = -1 %s %s", e, emsg);
2070 } else if (ret == 0 && sc->fmt->timeout)
2071 fprintf(trace->output, ") = 0 Timeout");
2072 else if (sc->fmt->hexret)
2073 fprintf(trace->output, ") = %#lx", ret);
2077 fputc('\n', trace->output);
2079 ttrace->entry_pending = false;
2082 thread__put(thread);
2086 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
2087 union perf_event *event __maybe_unused,
2088 struct perf_sample *sample)
2090 struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2091 struct thread_trace *ttrace;
2092 size_t filename_len, entry_str_len, to_move;
2093 ssize_t remaining_space;
2095 const char *filename = perf_evsel__rawptr(evsel, sample, "pathname");
2100 ttrace = thread__priv(thread);
2104 filename_len = strlen(filename);
2106 if (ttrace->filename.namelen < filename_len) {
2107 char *f = realloc(ttrace->filename.name, filename_len + 1);
2112 ttrace->filename.namelen = filename_len;
2113 ttrace->filename.name = f;
2116 strcpy(ttrace->filename.name, filename);
2117 ttrace->filename.pending_open = true;
2119 if (!ttrace->filename.ptr)
2122 entry_str_len = strlen(ttrace->entry_str);
2123 remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
2124 if (remaining_space <= 0)
2127 if (filename_len > (size_t)remaining_space) {
2128 filename += filename_len - remaining_space;
2129 filename_len = remaining_space;
2132 to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
2133 pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
2134 memmove(pos + filename_len, pos, to_move);
2135 memcpy(pos, filename, filename_len);
2137 ttrace->filename.ptr = 0;
2138 ttrace->filename.entry_str_pos = 0;
2143 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
2144 union perf_event *event __maybe_unused,
2145 struct perf_sample *sample)
2147 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
2148 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
2149 struct thread *thread = machine__findnew_thread(trace->host,
2152 struct thread_trace *ttrace = thread__trace(thread, trace->output);
2157 ttrace->runtime_ms += runtime_ms;
2158 trace->runtime_ms += runtime_ms;
2159 thread__put(thread);
2163 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
2165 perf_evsel__strval(evsel, sample, "comm"),
2166 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
2168 perf_evsel__intval(evsel, sample, "vruntime"));
2169 thread__put(thread);
2173 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
2174 union perf_event *event __maybe_unused,
2175 struct perf_sample *sample)
2177 trace__printf_interrupted_entry(trace, sample);
2178 trace__fprintf_tstamp(trace, sample->time, trace->output);
2180 if (trace->trace_syscalls)
2181 fprintf(trace->output, "( ): ");
2183 fprintf(trace->output, "%s:", evsel->name);
2185 if (evsel->tp_format) {
2186 event_format__fprintf(evsel->tp_format, sample->cpu,
2187 sample->raw_data, sample->raw_size,
2191 fprintf(trace->output, ")\n");
2195 static void print_location(FILE *f, struct perf_sample *sample,
2196 struct addr_location *al,
2197 bool print_dso, bool print_sym)
2200 if ((verbose || print_dso) && al->map)
2201 fprintf(f, "%s@", al->map->dso->long_name);
2203 if ((verbose || print_sym) && al->sym)
2204 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
2205 al->addr - al->sym->start);
2207 fprintf(f, "0x%" PRIx64, al->addr);
2209 fprintf(f, "0x%" PRIx64, sample->addr);
2212 static int trace__pgfault(struct trace *trace,
2213 struct perf_evsel *evsel,
2214 union perf_event *event,
2215 struct perf_sample *sample)
2217 struct thread *thread;
2218 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2219 struct addr_location al;
2220 char map_type = 'd';
2221 struct thread_trace *ttrace;
2224 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2225 ttrace = thread__trace(thread, trace->output);
2229 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
2234 if (trace->summary_only)
2237 thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
2240 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
2242 fprintf(trace->output, "%sfault [",
2243 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
2246 print_location(trace->output, sample, &al, false, true);
2248 fprintf(trace->output, "] => ");
2250 thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
2254 thread__find_addr_location(thread, cpumode,
2255 MAP__FUNCTION, sample->addr, &al);
2263 print_location(trace->output, sample, &al, true, false);
2265 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
2269 thread__put(thread);
2273 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
2275 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
2276 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
2279 if (trace->pid_list || trace->tid_list)
2285 static int trace__process_sample(struct perf_tool *tool,
2286 union perf_event *event,
2287 struct perf_sample *sample,
2288 struct perf_evsel *evsel,
2289 struct machine *machine __maybe_unused)
2291 struct trace *trace = container_of(tool, struct trace, tool);
2294 tracepoint_handler handler = evsel->handler;
2296 if (skip_sample(trace, sample))
2299 if (!trace->full_time && trace->base_time == 0)
2300 trace->base_time = sample->time;
2304 handler(trace, evsel, event, sample);
2310 static int parse_target_str(struct trace *trace)
2312 if (trace->opts.target.pid) {
2313 trace->pid_list = intlist__new(trace->opts.target.pid);
2314 if (trace->pid_list == NULL) {
2315 pr_err("Error parsing process id string\n");
2320 if (trace->opts.target.tid) {
2321 trace->tid_list = intlist__new(trace->opts.target.tid);
2322 if (trace->tid_list == NULL) {
2323 pr_err("Error parsing thread id string\n");
2331 static int trace__record(struct trace *trace, int argc, const char **argv)
2333 unsigned int rec_argc, i, j;
2334 const char **rec_argv;
2335 const char * const record_args[] = {
2342 const char * const sc_args[] = { "-e", };
2343 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2344 const char * const majpf_args[] = { "-e", "major-faults" };
2345 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2346 const char * const minpf_args[] = { "-e", "minor-faults" };
2347 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2349 /* +1 is for the event string below */
2350 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2351 majpf_args_nr + minpf_args_nr + argc;
2352 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2354 if (rec_argv == NULL)
2358 for (i = 0; i < ARRAY_SIZE(record_args); i++)
2359 rec_argv[j++] = record_args[i];
2361 if (trace->trace_syscalls) {
2362 for (i = 0; i < sc_args_nr; i++)
2363 rec_argv[j++] = sc_args[i];
2365 /* event string may be different for older kernels - e.g., RHEL6 */
2366 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2367 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2368 else if (is_valid_tracepoint("syscalls:sys_enter"))
2369 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2371 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2376 if (trace->trace_pgfaults & TRACE_PFMAJ)
2377 for (i = 0; i < majpf_args_nr; i++)
2378 rec_argv[j++] = majpf_args[i];
2380 if (trace->trace_pgfaults & TRACE_PFMIN)
2381 for (i = 0; i < minpf_args_nr; i++)
2382 rec_argv[j++] = minpf_args[i];
2384 for (i = 0; i < (unsigned int)argc; i++)
2385 rec_argv[j++] = argv[i];
2387 return cmd_record(j, rec_argv, NULL);
2390 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2392 static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2394 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2399 if (perf_evsel__field(evsel, "pathname") == NULL) {
2400 perf_evsel__delete(evsel);
2404 evsel->handler = trace__vfs_getname;
2405 perf_evlist__add(evlist, evsel);
2409 static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
2412 struct perf_evsel *evsel;
2413 struct perf_event_attr attr = {
2414 .type = PERF_TYPE_SOFTWARE,
2418 attr.config = config;
2419 attr.sample_period = 1;
2421 event_attr_init(&attr);
2423 evsel = perf_evsel__new(&attr);
2427 evsel->handler = trace__pgfault;
2428 perf_evlist__add(evlist, evsel);
2433 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2435 const u32 type = event->header.type;
2436 struct perf_evsel *evsel;
2438 if (!trace->full_time && trace->base_time == 0)
2439 trace->base_time = sample->time;
2441 if (type != PERF_RECORD_SAMPLE) {
2442 trace__process_event(trace, trace->host, event, sample);
2446 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2447 if (evsel == NULL) {
2448 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2452 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2453 sample->raw_data == NULL) {
2454 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2455 perf_evsel__name(evsel), sample->tid,
2456 sample->cpu, sample->raw_size);
2458 tracepoint_handler handler = evsel->handler;
2459 handler(trace, evsel, event, sample);
2463 static int trace__add_syscall_newtp(struct trace *trace)
2466 struct perf_evlist *evlist = trace->evlist;
2467 struct perf_evsel *sys_enter, *sys_exit;
2469 sys_enter = perf_evsel__syscall_newtp("sys_enter", trace__sys_enter);
2470 if (sys_enter == NULL)
2473 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2474 goto out_delete_sys_enter;
2476 sys_exit = perf_evsel__syscall_newtp("sys_exit", trace__sys_exit);
2477 if (sys_exit == NULL)
2478 goto out_delete_sys_enter;
2480 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2481 goto out_delete_sys_exit;
2483 perf_evlist__add(evlist, sys_enter);
2484 perf_evlist__add(evlist, sys_exit);
2486 trace->syscalls.events.sys_enter = sys_enter;
2487 trace->syscalls.events.sys_exit = sys_exit;
2493 out_delete_sys_exit:
2494 perf_evsel__delete_priv(sys_exit);
2495 out_delete_sys_enter:
2496 perf_evsel__delete_priv(sys_enter);
2500 static int trace__set_ev_qualifier_filter(struct trace *trace)
2503 char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2504 trace->ev_qualifier_ids.nr,
2505 trace->ev_qualifier_ids.entries);
2510 if (!perf_evsel__append_filter(trace->syscalls.events.sys_enter, "&&", filter))
2511 err = perf_evsel__append_filter(trace->syscalls.events.sys_exit, "&&", filter);
2521 static int trace__run(struct trace *trace, int argc, const char **argv)
2523 struct perf_evlist *evlist = trace->evlist;
2524 struct perf_evsel *evsel;
2526 unsigned long before;
2527 const bool forks = argc > 0;
2528 bool draining = false;
2532 if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
2533 goto out_error_raw_syscalls;
2535 if (trace->trace_syscalls)
2536 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
2538 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2539 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
2543 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2544 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2548 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2549 trace__sched_stat_runtime))
2550 goto out_error_sched_stat_runtime;
2552 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2554 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2555 goto out_delete_evlist;
2558 err = trace__symbols_init(trace, evlist);
2560 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2561 goto out_delete_evlist;
2564 perf_evlist__config(evlist, &trace->opts);
2566 signal(SIGCHLD, sig_handler);
2567 signal(SIGINT, sig_handler);
2570 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2573 fprintf(trace->output, "Couldn't run the workload!\n");
2574 goto out_delete_evlist;
2578 err = perf_evlist__open(evlist);
2580 goto out_error_open;
2583 * Better not use !target__has_task() here because we need to cover the
2584 * case where no threads were specified in the command line, but a
2585 * workload was, and in that case we will fill in the thread_map when
2586 * we fork the workload in perf_evlist__prepare_workload.
2588 if (trace->filter_pids.nr > 0)
2589 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2590 else if (thread_map__pid(evlist->threads, 0) == -1)
2591 err = perf_evlist__set_filter_pid(evlist, getpid());
2596 if (trace->ev_qualifier_ids.nr > 0) {
2597 err = trace__set_ev_qualifier_filter(trace);
2601 pr_debug("event qualifier tracepoint filter: %s\n",
2602 trace->syscalls.events.sys_exit->filter);
2605 err = perf_evlist__apply_filters(evlist, &evsel);
2607 goto out_error_apply_filters;
2609 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2611 goto out_error_mmap;
2613 if (!target__none(&trace->opts.target))
2614 perf_evlist__enable(evlist);
2617 perf_evlist__start_workload(evlist);
2619 trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
2620 evlist->threads->nr > 1 ||
2621 perf_evlist__first(evlist)->attr.inherit;
2623 before = trace->nr_events;
2625 for (i = 0; i < evlist->nr_mmaps; i++) {
2626 union perf_event *event;
2628 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2629 struct perf_sample sample;
2633 err = perf_evlist__parse_sample(evlist, event, &sample);
2635 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2639 trace__handle_event(trace, event, &sample);
2641 perf_evlist__mmap_consume(evlist, i);
2646 if (done && !draining) {
2647 perf_evlist__disable(evlist);
2653 if (trace->nr_events == before) {
2654 int timeout = done ? 100 : -1;
2656 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2657 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2667 thread__zput(trace->current);
2669 perf_evlist__disable(evlist);
2673 trace__fprintf_thread_summary(trace, trace->output);
2675 if (trace->show_tool_stats) {
2676 fprintf(trace->output, "Stats:\n "
2677 " vfs_getname : %" PRIu64 "\n"
2678 " proc_getname: %" PRIu64 "\n",
2679 trace->stats.vfs_getname,
2680 trace->stats.proc_getname);
2685 perf_evlist__delete(evlist);
2686 trace->evlist = NULL;
2687 trace->live = false;
2690 char errbuf[BUFSIZ];
2692 out_error_sched_stat_runtime:
2693 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2696 out_error_raw_syscalls:
2697 tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2701 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2705 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2708 fprintf(trace->output, "%s\n", errbuf);
2709 goto out_delete_evlist;
2711 out_error_apply_filters:
2712 fprintf(trace->output,
2713 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2714 evsel->filter, perf_evsel__name(evsel), errno,
2715 strerror_r(errno, errbuf, sizeof(errbuf)));
2716 goto out_delete_evlist;
2719 fprintf(trace->output, "Not enough memory to run!\n");
2720 goto out_delete_evlist;
2723 fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2724 goto out_delete_evlist;
2727 static int trace__replay(struct trace *trace)
2729 const struct perf_evsel_str_handler handlers[] = {
2730 { "probe:vfs_getname", trace__vfs_getname, },
2732 struct perf_data_file file = {
2734 .mode = PERF_DATA_MODE_READ,
2735 .force = trace->force,
2737 struct perf_session *session;
2738 struct perf_evsel *evsel;
2741 trace->tool.sample = trace__process_sample;
2742 trace->tool.mmap = perf_event__process_mmap;
2743 trace->tool.mmap2 = perf_event__process_mmap2;
2744 trace->tool.comm = perf_event__process_comm;
2745 trace->tool.exit = perf_event__process_exit;
2746 trace->tool.fork = perf_event__process_fork;
2747 trace->tool.attr = perf_event__process_attr;
2748 trace->tool.tracing_data = perf_event__process_tracing_data;
2749 trace->tool.build_id = perf_event__process_build_id;
2751 trace->tool.ordered_events = true;
2752 trace->tool.ordering_requires_timestamps = true;
2754 /* add tid to output */
2755 trace->multiple_threads = true;
2757 session = perf_session__new(&file, false, &trace->tool);
2758 if (session == NULL)
2761 if (symbol__init(&session->header.env) < 0)
2764 trace->host = &session->machines.host;
2766 err = perf_session__set_tracepoints_handlers(session, handlers);
2770 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2771 "raw_syscalls:sys_enter");
2772 /* older kernels have syscalls tp versus raw_syscalls */
2774 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2775 "syscalls:sys_enter");
2778 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2779 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2780 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2784 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2785 "raw_syscalls:sys_exit");
2787 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2788 "syscalls:sys_exit");
2790 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2791 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2792 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2796 evlist__for_each(session->evlist, evsel) {
2797 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2798 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2799 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2800 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2801 evsel->handler = trace__pgfault;
2804 err = parse_target_str(trace);
2810 err = perf_session__process_events(session);
2812 pr_err("Failed to process events, error %d", err);
2814 else if (trace->summary)
2815 trace__fprintf_thread_summary(trace, trace->output);
2818 perf_session__delete(session);
2823 static size_t trace__fprintf_threads_header(FILE *fp)
2827 printed = fprintf(fp, "\n Summary of events:\n\n");
2832 static size_t thread__dump_stats(struct thread_trace *ttrace,
2833 struct trace *trace, FILE *fp)
2835 struct stats *stats;
2838 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2843 printed += fprintf(fp, "\n");
2845 printed += fprintf(fp, " syscall calls total min avg max stddev\n");
2846 printed += fprintf(fp, " (msec) (msec) (msec) (msec) (%%)\n");
2847 printed += fprintf(fp, " --------------- -------- --------- --------- --------- --------- ------\n");
2849 /* each int_node is a syscall */
2851 stats = inode->priv;
2853 double min = (double)(stats->min) / NSEC_PER_MSEC;
2854 double max = (double)(stats->max) / NSEC_PER_MSEC;
2855 double avg = avg_stats(stats);
2857 u64 n = (u64) stats->n;
2859 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2860 avg /= NSEC_PER_MSEC;
2862 sc = &trace->syscalls.table[inode->i];
2863 printed += fprintf(fp, " %-15s", sc->name);
2864 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
2865 n, avg * n, min, avg);
2866 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2869 inode = intlist__next(inode);
2872 printed += fprintf(fp, "\n\n");
2877 /* struct used to pass data to per-thread function */
2878 struct summary_data {
2880 struct trace *trace;
2884 static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2886 struct summary_data *data = priv;
2887 FILE *fp = data->fp;
2888 size_t printed = data->printed;
2889 struct trace *trace = data->trace;
2890 struct thread_trace *ttrace = thread__priv(thread);
2896 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2898 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2899 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2900 printed += fprintf(fp, "%.1f%%", ratio);
2902 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2904 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2905 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2906 printed += thread__dump_stats(ttrace, trace, fp);
2908 data->printed += printed;
2913 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2915 struct summary_data data = {
2919 data.printed = trace__fprintf_threads_header(fp);
2921 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2923 return data.printed;
2926 static int trace__set_duration(const struct option *opt, const char *str,
2927 int unset __maybe_unused)
2929 struct trace *trace = opt->value;
2931 trace->duration_filter = atof(str);
2935 static int trace__set_filter_pids(const struct option *opt, const char *str,
2936 int unset __maybe_unused)
2940 struct trace *trace = opt->value;
2942 * FIXME: introduce a intarray class, plain parse csv and create a
2943 * { int nr, int entries[] } struct...
2945 struct intlist *list = intlist__new(str);
2950 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2951 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2953 if (trace->filter_pids.entries == NULL)
2956 trace->filter_pids.entries[0] = getpid();
2958 for (i = 1; i < trace->filter_pids.nr; ++i)
2959 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2961 intlist__delete(list);
2967 static int trace__open_output(struct trace *trace, const char *filename)
2971 if (!stat(filename, &st) && st.st_size) {
2972 char oldname[PATH_MAX];
2974 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2976 rename(filename, oldname);
2979 trace->output = fopen(filename, "w");
2981 return trace->output == NULL ? -errno : 0;
2984 static int parse_pagefaults(const struct option *opt, const char *str,
2985 int unset __maybe_unused)
2987 int *trace_pgfaults = opt->value;
2989 if (strcmp(str, "all") == 0)
2990 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2991 else if (strcmp(str, "maj") == 0)
2992 *trace_pgfaults |= TRACE_PFMAJ;
2993 else if (strcmp(str, "min") == 0)
2994 *trace_pgfaults |= TRACE_PFMIN;
3001 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
3003 struct perf_evsel *evsel;
3005 evlist__for_each(evlist, evsel)
3006 evsel->handler = handler;
3009 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
3011 const char *trace_usage[] = {
3012 "perf trace [<options>] [<command>]",
3013 "perf trace [<options>] -- <command> [<options>]",
3014 "perf trace record [<options>] [<command>]",
3015 "perf trace record [<options>] -- <command> [<options>]",
3018 struct trace trace = {
3020 .machine = audit_detect_machine(),
3021 .open_id = audit_name_to_syscall("open", trace.audit.machine),
3031 .user_freq = UINT_MAX,
3032 .user_interval = ULLONG_MAX,
3033 .no_buffering = true,
3034 .mmap_pages = UINT_MAX,
3035 .proc_map_timeout = 500,
3039 .trace_syscalls = true,
3041 const char *output_name = NULL;
3042 const char *ev_qualifier_str = NULL;
3043 const struct option trace_options[] = {
3044 OPT_CALLBACK(0, "event", &trace.evlist, "event",
3045 "event selector. use 'perf list' to list available events",
3046 parse_events_option),
3047 OPT_BOOLEAN(0, "comm", &trace.show_comm,
3048 "show the thread COMM next to its id"),
3049 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
3050 OPT_STRING('e', "expr", &ev_qualifier_str, "expr", "list of syscalls to trace"),
3051 OPT_STRING('o', "output", &output_name, "file", "output file name"),
3052 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
3053 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
3054 "trace events on existing process id"),
3055 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
3056 "trace events on existing thread id"),
3057 OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
3058 "pids to filter (by the kernel)", trace__set_filter_pids),
3059 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
3060 "system-wide collection from all CPUs"),
3061 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
3062 "list of cpus to monitor"),
3063 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
3064 "child tasks do not inherit counters"),
3065 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
3066 "number of mmap data pages",
3067 perf_evlist__parse_mmap_pages),
3068 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
3070 OPT_CALLBACK(0, "duration", &trace, "float",
3071 "show only events with duration > N.M ms",
3072 trace__set_duration),
3073 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
3074 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
3075 OPT_BOOLEAN('T', "time", &trace.full_time,
3076 "Show full timestamp, not time relative to first start"),
3077 OPT_BOOLEAN('s', "summary", &trace.summary_only,
3078 "Show only syscall summary with statistics"),
3079 OPT_BOOLEAN('S', "with-summary", &trace.summary,
3080 "Show all syscalls and summary with statistics"),
3081 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
3082 "Trace pagefaults", parse_pagefaults, "maj"),
3083 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
3084 OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
3085 OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
3086 "per thread proc mmap processing timeout in ms"),
3089 const char * const trace_subcommands[] = { "record", NULL };
3093 signal(SIGSEGV, sighandler_dump_stack);
3094 signal(SIGFPE, sighandler_dump_stack);
3096 trace.evlist = perf_evlist__new();
3098 if (trace.evlist == NULL) {
3099 pr_err("Not enough memory to run!\n");
3104 argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
3105 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
3107 if (trace.trace_pgfaults) {
3108 trace.opts.sample_address = true;
3109 trace.opts.sample_time = true;
3112 if (trace.evlist->nr_entries > 0)
3113 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
3115 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
3116 return trace__record(&trace, argc-1, &argv[1]);
3118 /* summary_only implies summary option, but don't overwrite summary if set */
3119 if (trace.summary_only)
3120 trace.summary = trace.summary_only;
3122 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
3123 trace.evlist->nr_entries == 0 /* Was --events used? */) {
3124 pr_err("Please specify something to trace.\n");
3128 if (output_name != NULL) {
3129 err = trace__open_output(&trace, output_name);
3131 perror("failed to create output file");
3136 if (ev_qualifier_str != NULL) {
3137 const char *s = ev_qualifier_str;
3138 struct strlist_config slist_config = {
3139 .dirname = system_path(STRACE_GROUPS_DIR),
3142 trace.not_ev_qualifier = *s == '!';
3143 if (trace.not_ev_qualifier)
3145 trace.ev_qualifier = strlist__new(s, &slist_config);
3146 if (trace.ev_qualifier == NULL) {
3147 fputs("Not enough memory to parse event qualifier",
3153 err = trace__validate_ev_qualifier(&trace);
3158 err = target__validate(&trace.opts.target);
3160 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3161 fprintf(trace.output, "%s", bf);
3165 err = target__parse_uid(&trace.opts.target);
3167 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3168 fprintf(trace.output, "%s", bf);
3172 if (!argc && target__none(&trace.opts.target))
3173 trace.opts.target.system_wide = true;
3176 err = trace__replay(&trace);
3178 err = trace__run(&trace, argc, argv);
3181 if (output_name != NULL)
3182 fclose(trace.output);