1 #include <traceevent/event-parse.h>
3 #include "util/color.h"
4 #include "util/debug.h"
5 #include "util/evlist.h"
6 #include "util/machine.h"
7 #include "util/session.h"
8 #include "util/thread.h"
9 #include "util/parse-options.h"
10 #include "util/strlist.h"
11 #include "util/intlist.h"
12 #include "util/thread_map.h"
16 #include <sys/eventfd.h>
18 #include <linux/futex.h>
20 /* For older distros: */
22 # define MAP_STACK 0x20000
26 # define MADV_HWPOISON 100
29 #ifndef MADV_MERGEABLE
30 # define MADV_MERGEABLE 12
33 #ifndef MADV_UNMERGEABLE
34 # define MADV_UNMERGEABLE 13
49 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
50 .nr_entries = ARRAY_SIZE(array), \
54 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
55 struct syscall_arg *arg)
58 struct strarray *sa = arg->parm;
60 if (idx < 0 || idx >= sa->nr_entries)
61 return scnprintf(bf, size, "%d", idx);
63 return scnprintf(bf, size, "%s", sa->entries[idx]);
66 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
68 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
69 struct syscall_arg *arg)
71 return scnprintf(bf, size, "%#lx", arg->val);
74 #define SCA_HEX syscall_arg__scnprintf_hex
76 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
77 struct syscall_arg *arg)
79 int printed = 0, prot = arg->val;
81 if (prot == PROT_NONE)
82 return scnprintf(bf, size, "NONE");
83 #define P_MMAP_PROT(n) \
84 if (prot & PROT_##n) { \
85 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
95 P_MMAP_PROT(GROWSDOWN);
100 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
105 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
107 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
108 struct syscall_arg *arg)
110 int printed = 0, flags = arg->val;
112 #define P_MMAP_FLAG(n) \
113 if (flags & MAP_##n) { \
114 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
119 P_MMAP_FLAG(PRIVATE);
123 P_MMAP_FLAG(ANONYMOUS);
124 P_MMAP_FLAG(DENYWRITE);
125 P_MMAP_FLAG(EXECUTABLE);
128 P_MMAP_FLAG(GROWSDOWN);
130 P_MMAP_FLAG(HUGETLB);
133 P_MMAP_FLAG(NONBLOCK);
134 P_MMAP_FLAG(NORESERVE);
135 P_MMAP_FLAG(POPULATE);
137 #ifdef MAP_UNINITIALIZED
138 P_MMAP_FLAG(UNINITIALIZED);
143 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
148 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
150 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
151 struct syscall_arg *arg)
153 int behavior = arg->val;
156 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
159 P_MADV_BHV(SEQUENTIAL);
160 P_MADV_BHV(WILLNEED);
161 P_MADV_BHV(DONTNEED);
163 P_MADV_BHV(DONTFORK);
165 P_MADV_BHV(HWPOISON);
166 #ifdef MADV_SOFT_OFFLINE
167 P_MADV_BHV(SOFT_OFFLINE);
169 P_MADV_BHV(MERGEABLE);
170 P_MADV_BHV(UNMERGEABLE);
172 P_MADV_BHV(HUGEPAGE);
174 #ifdef MADV_NOHUGEPAGE
175 P_MADV_BHV(NOHUGEPAGE);
178 P_MADV_BHV(DONTDUMP);
187 return scnprintf(bf, size, "%#x", behavior);
190 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
192 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
193 struct syscall_arg *arg)
195 int printed = 0, op = arg->val;
198 return scnprintf(bf, size, "NONE");
200 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
201 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
216 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
221 #define SCA_FLOCK syscall_arg__scnprintf_flock
223 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
225 enum syscall_futex_args {
226 SCF_UADDR = (1 << 0),
229 SCF_TIMEOUT = (1 << 3),
230 SCF_UADDR2 = (1 << 4),
234 int cmd = op & FUTEX_CMD_MASK;
238 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
239 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
240 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
241 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
242 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
243 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
244 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
245 P_FUTEX_OP(WAKE_OP); break;
246 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
247 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
248 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
249 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
250 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
251 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
252 default: printed = scnprintf(bf, size, "%#x", cmd); break;
255 if (op & FUTEX_PRIVATE_FLAG)
256 printed += scnprintf(bf + printed, size - printed, "|PRIV");
258 if (op & FUTEX_CLOCK_REALTIME)
259 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
264 #define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
266 static const char *epoll_ctl_ops[] = { [1] = "ADD", "DEL", "MOD", };
267 static DEFINE_STRARRAY(epoll_ctl_ops);
269 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
270 static DEFINE_STRARRAY(itimers);
272 static const char *whences[] = { "SET", "CUR", "END",
280 static DEFINE_STRARRAY(whences);
282 static const char *fcntl_cmds[] = {
283 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
284 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
285 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
288 static DEFINE_STRARRAY(fcntl_cmds);
290 static const char *rlimit_resources[] = {
291 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
292 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
295 static DEFINE_STRARRAY(rlimit_resources);
297 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
298 static DEFINE_STRARRAY(sighow);
300 static const char *socket_families[] = {
301 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
302 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
303 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
304 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
305 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
306 "ALG", "NFC", "VSOCK",
308 static DEFINE_STRARRAY(socket_families);
310 #ifndef SOCK_TYPE_MASK
311 #define SOCK_TYPE_MASK 0xf
314 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
315 struct syscall_arg *arg)
319 flags = type & ~SOCK_TYPE_MASK;
321 type &= SOCK_TYPE_MASK;
323 * Can't use a strarray, MIPS may override for ABI reasons.
326 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
331 P_SK_TYPE(SEQPACKET);
336 printed = scnprintf(bf, size, "%#x", type);
339 #define P_SK_FLAG(n) \
340 if (flags & SOCK_##n) { \
341 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
342 flags &= ~SOCK_##n; \
350 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
355 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
358 #define MSG_PROBE 0x10
360 #ifndef MSG_SENDPAGE_NOTLAST
361 #define MSG_SENDPAGE_NOTLAST 0x20000
364 #define MSG_FASTOPEN 0x20000000
367 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
368 struct syscall_arg *arg)
370 int printed = 0, flags = arg->val;
373 return scnprintf(bf, size, "NONE");
374 #define P_MSG_FLAG(n) \
375 if (flags & MSG_##n) { \
376 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
382 P_MSG_FLAG(DONTROUTE);
387 P_MSG_FLAG(DONTWAIT);
394 P_MSG_FLAG(ERRQUEUE);
395 P_MSG_FLAG(NOSIGNAL);
397 P_MSG_FLAG(WAITFORONE);
398 P_MSG_FLAG(SENDPAGE_NOTLAST);
399 P_MSG_FLAG(FASTOPEN);
400 P_MSG_FLAG(CMSG_CLOEXEC);
404 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
409 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
411 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
412 struct syscall_arg *arg)
417 if (mode == F_OK) /* 0 */
418 return scnprintf(bf, size, "F");
420 if (mode & n##_OK) { \
421 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
431 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
436 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
438 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
439 struct syscall_arg *arg)
441 int printed = 0, flags = arg->val;
443 if (!(flags & O_CREAT))
444 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
447 return scnprintf(bf, size, "RDONLY");
449 if (flags & O_##n) { \
450 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
474 if ((flags & O_SYNC) == O_SYNC)
475 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
487 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
492 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
494 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
495 struct syscall_arg *arg)
497 int printed = 0, flags = arg->val;
500 return scnprintf(bf, size, "NONE");
502 if (flags & EFD_##n) { \
503 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
513 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
518 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
520 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
525 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
560 return scnprintf(bf, size, "%#x", sig);
563 #define SCA_SIGNUM syscall_arg__scnprintf_signum
565 #define STRARRAY(arg, name, array) \
566 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
567 .arg_parm = { [arg] = &strarray__##array, }
569 static struct syscall_fmt {
572 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
578 { .name = "access", .errmsg = true,
579 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
580 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
581 { .name = "brk", .hexret = true,
582 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
583 { .name = "connect", .errmsg = true, },
584 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
585 { .name = "eventfd2", .errmsg = true,
586 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
587 { .name = "fcntl", .errmsg = true, STRARRAY(1, cmd, fcntl_cmds), },
588 { .name = "flock", .errmsg = true,
589 .arg_scnprintf = { [1] = SCA_FLOCK, /* cmd */ }, },
590 { .name = "fstat", .errmsg = true, .alias = "newfstat", },
591 { .name = "fstatat", .errmsg = true, .alias = "newfstatat", },
592 { .name = "futex", .errmsg = true,
593 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
594 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
595 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
596 { .name = "ioctl", .errmsg = true,
597 .arg_scnprintf = { [2] = SCA_HEX, /* arg */ }, },
598 { .name = "kill", .errmsg = true,
599 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
600 { .name = "lseek", .errmsg = true, STRARRAY(2, whence, whences), },
601 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
602 { .name = "madvise", .errmsg = true,
603 .arg_scnprintf = { [0] = SCA_HEX, /* start */
604 [2] = SCA_MADV_BHV, /* behavior */ }, },
605 { .name = "mmap", .hexret = true,
606 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
607 [2] = SCA_MMAP_PROT, /* prot */
608 [3] = SCA_MMAP_FLAGS, /* flags */ }, },
609 { .name = "mprotect", .errmsg = true,
610 .arg_scnprintf = { [0] = SCA_HEX, /* start */
611 [2] = SCA_MMAP_PROT, /* prot */ }, },
612 { .name = "mremap", .hexret = true,
613 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
614 [4] = SCA_HEX, /* new_addr */ }, },
615 { .name = "munmap", .errmsg = true,
616 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
617 { .name = "open", .errmsg = true,
618 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
619 { .name = "open_by_handle_at", .errmsg = true,
620 .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
621 { .name = "openat", .errmsg = true,
622 .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
623 { .name = "poll", .errmsg = true, .timeout = true, },
624 { .name = "ppoll", .errmsg = true, .timeout = true, },
625 { .name = "pread", .errmsg = true, .alias = "pread64", },
626 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
627 { .name = "pwrite", .errmsg = true, .alias = "pwrite64", },
628 { .name = "read", .errmsg = true, },
629 { .name = "recvfrom", .errmsg = true,
630 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
631 { .name = "recvmmsg", .errmsg = true,
632 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
633 { .name = "recvmsg", .errmsg = true,
634 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
635 { .name = "rt_sigaction", .errmsg = true,
636 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
637 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
638 { .name = "rt_sigqueueinfo", .errmsg = true,
639 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
640 { .name = "rt_tgsigqueueinfo", .errmsg = true,
641 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
642 { .name = "select", .errmsg = true, .timeout = true, },
643 { .name = "sendmmsg", .errmsg = true,
644 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
645 { .name = "sendmsg", .errmsg = true,
646 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
647 { .name = "sendto", .errmsg = true,
648 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
649 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
650 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
651 { .name = "socket", .errmsg = true,
652 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
653 [1] = SCA_SK_TYPE, /* type */ },
654 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
655 { .name = "socketpair", .errmsg = true,
656 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
657 [1] = SCA_SK_TYPE, /* type */ },
658 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
659 { .name = "stat", .errmsg = true, .alias = "newstat", },
660 { .name = "tgkill", .errmsg = true,
661 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
662 { .name = "tkill", .errmsg = true,
663 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
664 { .name = "uname", .errmsg = true, .alias = "newuname", },
667 static int syscall_fmt__cmp(const void *name, const void *fmtp)
669 const struct syscall_fmt *fmt = fmtp;
670 return strcmp(name, fmt->name);
673 static struct syscall_fmt *syscall_fmt__find(const char *name)
675 const int nmemb = ARRAY_SIZE(syscall_fmts);
676 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
680 struct event_format *tp_format;
683 struct syscall_fmt *fmt;
684 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
688 static size_t fprintf_duration(unsigned long t, FILE *fp)
690 double duration = (double)t / NSEC_PER_MSEC;
691 size_t printed = fprintf(fp, "(");
694 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
695 else if (duration >= 0.01)
696 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
698 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
699 return printed + fprintf(fp, "): ");
702 struct thread_trace {
706 unsigned long nr_events;
711 static struct thread_trace *thread_trace__new(void)
713 return zalloc(sizeof(struct thread_trace));
716 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
718 struct thread_trace *ttrace;
723 if (thread->priv == NULL)
724 thread->priv = thread_trace__new();
726 if (thread->priv == NULL)
729 ttrace = thread->priv;
734 color_fprintf(fp, PERF_COLOR_RED,
735 "WARNING: not enough memory, dropping samples!\n");
740 struct perf_tool tool;
744 struct syscall *table;
746 struct perf_record_opts opts;
751 unsigned long nr_events;
752 struct strlist *ev_qualifier;
753 bool not_ev_qualifier;
754 struct intlist *tid_list;
755 struct intlist *pid_list;
757 bool multiple_threads;
759 double duration_filter;
763 static bool trace__filter_duration(struct trace *trace, double t)
765 return t < (trace->duration_filter * NSEC_PER_MSEC);
768 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
770 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
772 return fprintf(fp, "%10.3f ", ts);
775 static bool done = false;
777 static void sig_handler(int sig __maybe_unused)
782 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
783 u64 duration, u64 tstamp, FILE *fp)
785 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
786 printed += fprintf_duration(duration, fp);
788 if (trace->multiple_threads) {
789 if (trace->show_comm)
790 printed += fprintf(fp, "%.14s/", thread->comm);
791 printed += fprintf(fp, "%d ", thread->tid);
797 static int trace__process_event(struct trace *trace, struct machine *machine,
798 union perf_event *event)
802 switch (event->header.type) {
803 case PERF_RECORD_LOST:
804 color_fprintf(trace->output, PERF_COLOR_RED,
805 "LOST %" PRIu64 " events!\n", event->lost.lost);
806 ret = machine__process_lost_event(machine, event);
808 ret = machine__process_event(machine, event);
815 static int trace__tool_process(struct perf_tool *tool,
816 union perf_event *event,
817 struct perf_sample *sample __maybe_unused,
818 struct machine *machine)
820 struct trace *trace = container_of(tool, struct trace, tool);
821 return trace__process_event(trace, machine, event);
824 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
826 int err = symbol__init();
831 machine__init(&trace->host, "", HOST_KERNEL_ID);
832 machine__create_kernel_maps(&trace->host);
834 if (perf_target__has_task(&trace->opts.target)) {
835 err = perf_event__synthesize_thread_map(&trace->tool, evlist->threads,
839 err = perf_event__synthesize_threads(&trace->tool, trace__tool_process,
849 static int syscall__set_arg_fmts(struct syscall *sc)
851 struct format_field *field;
854 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
855 if (sc->arg_scnprintf == NULL)
859 sc->arg_parm = sc->fmt->arg_parm;
861 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
862 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
863 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
864 else if (field->flags & FIELD_IS_POINTER)
865 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
872 static int trace__read_syscall_info(struct trace *trace, int id)
876 const char *name = audit_syscall_to_name(id, trace->audit_machine);
881 if (id > trace->syscalls.max) {
882 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
884 if (nsyscalls == NULL)
887 if (trace->syscalls.max != -1) {
888 memset(nsyscalls + trace->syscalls.max + 1, 0,
889 (id - trace->syscalls.max) * sizeof(*sc));
891 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
894 trace->syscalls.table = nsyscalls;
895 trace->syscalls.max = id;
898 sc = trace->syscalls.table + id;
901 if (trace->ev_qualifier) {
902 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
904 if (!(in ^ trace->not_ev_qualifier)) {
907 * No need to do read tracepoint information since this will be
914 sc->fmt = syscall_fmt__find(sc->name);
916 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
917 sc->tp_format = event_format__new("syscalls", tp_name);
919 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
920 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
921 sc->tp_format = event_format__new("syscalls", tp_name);
924 if (sc->tp_format == NULL)
927 return syscall__set_arg_fmts(sc);
930 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
935 if (sc->tp_format != NULL) {
936 struct format_field *field;
938 struct syscall_arg arg = {
943 for (field = sc->tp_format->format.fields->next; field;
944 field = field->next, ++arg.idx, bit <<= 1) {
948 * Suppress this argument if its value is zero and
949 * and we don't have a string associated in an
952 if (args[arg.idx] == 0 &&
953 !(sc->arg_scnprintf &&
954 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
955 sc->arg_parm[arg.idx]))
958 printed += scnprintf(bf + printed, size - printed,
959 "%s%s: ", printed ? ", " : "", field->name);
960 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
961 arg.val = args[arg.idx];
963 arg.parm = sc->arg_parm[arg.idx];
964 printed += sc->arg_scnprintf[arg.idx](bf + printed,
965 size - printed, &arg);
967 printed += scnprintf(bf + printed, size - printed,
968 "%ld", args[arg.idx]);
975 printed += scnprintf(bf + printed, size - printed,
977 printed ? ", " : "", i, args[i]);
985 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
986 struct perf_sample *sample);
988 static struct syscall *trace__syscall_info(struct trace *trace,
989 struct perf_evsel *evsel,
990 struct perf_sample *sample)
992 int id = perf_evsel__intval(evsel, sample, "id");
997 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
998 * before that, leaving at a higher verbosity level till that is
999 * explained. Reproduced with plain ftrace with:
1001 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1002 * grep "NR -1 " /t/trace_pipe
1004 * After generating some load on the machine.
1008 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1009 id, perf_evsel__name(evsel), ++n);
1014 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1015 trace__read_syscall_info(trace, id))
1018 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1021 return &trace->syscalls.table[id];
1025 fprintf(trace->output, "Problems reading syscall %d", id);
1026 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1027 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1028 fputs(" information\n", trace->output);
1033 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1034 struct perf_sample *sample)
1039 struct thread *thread;
1040 struct syscall *sc = trace__syscall_info(trace, evsel, sample);
1041 struct thread_trace *ttrace;
1049 thread = machine__findnew_thread(&trace->host, sample->pid,
1051 ttrace = thread__trace(thread, trace->output);
1055 args = perf_evsel__rawptr(evsel, sample, "args");
1057 fprintf(trace->output, "Problems reading syscall arguments\n");
1061 ttrace = thread->priv;
1063 if (ttrace->entry_str == NULL) {
1064 ttrace->entry_str = malloc(1024);
1065 if (!ttrace->entry_str)
1069 ttrace->entry_time = sample->time;
1070 msg = ttrace->entry_str;
1071 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1073 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed, args);
1075 if (!strcmp(sc->name, "exit_group") || !strcmp(sc->name, "exit")) {
1076 if (!trace->duration_filter) {
1077 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1078 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1081 ttrace->entry_pending = true;
1086 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1087 struct perf_sample *sample)
1091 struct thread *thread;
1092 struct syscall *sc = trace__syscall_info(trace, evsel, sample);
1093 struct thread_trace *ttrace;
1101 thread = machine__findnew_thread(&trace->host, sample->pid,
1103 ttrace = thread__trace(thread, trace->output);
1107 ret = perf_evsel__intval(evsel, sample, "ret");
1109 ttrace = thread->priv;
1111 ttrace->exit_time = sample->time;
1113 if (ttrace->entry_time) {
1114 duration = sample->time - ttrace->entry_time;
1115 if (trace__filter_duration(trace, duration))
1117 } else if (trace->duration_filter)
1120 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1122 if (ttrace->entry_pending) {
1123 fprintf(trace->output, "%-70s", ttrace->entry_str);
1125 fprintf(trace->output, " ... [");
1126 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1127 fprintf(trace->output, "]: %s()", sc->name);
1130 if (sc->fmt == NULL) {
1132 fprintf(trace->output, ") = %d", ret);
1133 } else if (ret < 0 && sc->fmt->errmsg) {
1135 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1136 *e = audit_errno_to_name(-ret);
1138 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1139 } else if (ret == 0 && sc->fmt->timeout)
1140 fprintf(trace->output, ") = 0 Timeout");
1141 else if (sc->fmt->hexret)
1142 fprintf(trace->output, ") = %#x", ret);
1146 fputc('\n', trace->output);
1148 ttrace->entry_pending = false;
1153 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1154 struct perf_sample *sample)
1156 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1157 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1158 struct thread *thread = machine__findnew_thread(&trace->host,
1161 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1166 ttrace->runtime_ms += runtime_ms;
1167 trace->runtime_ms += runtime_ms;
1171 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1173 perf_evsel__strval(evsel, sample, "comm"),
1174 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1176 perf_evsel__intval(evsel, sample, "vruntime"));
1180 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1182 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1183 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1186 if (trace->pid_list || trace->tid_list)
1192 static int trace__process_sample(struct perf_tool *tool,
1193 union perf_event *event __maybe_unused,
1194 struct perf_sample *sample,
1195 struct perf_evsel *evsel,
1196 struct machine *machine __maybe_unused)
1198 struct trace *trace = container_of(tool, struct trace, tool);
1201 tracepoint_handler handler = evsel->handler.func;
1203 if (skip_sample(trace, sample))
1206 if (!trace->full_time && trace->base_time == 0)
1207 trace->base_time = sample->time;
1210 handler(trace, evsel, sample);
1216 perf_session__has_tp(struct perf_session *session, const char *name)
1218 struct perf_evsel *evsel;
1220 evsel = perf_evlist__find_tracepoint_by_name(session->evlist, name);
1222 return evsel != NULL;
1225 static int parse_target_str(struct trace *trace)
1227 if (trace->opts.target.pid) {
1228 trace->pid_list = intlist__new(trace->opts.target.pid);
1229 if (trace->pid_list == NULL) {
1230 pr_err("Error parsing process id string\n");
1235 if (trace->opts.target.tid) {
1236 trace->tid_list = intlist__new(trace->opts.target.tid);
1237 if (trace->tid_list == NULL) {
1238 pr_err("Error parsing thread id string\n");
1246 static int trace__run(struct trace *trace, int argc, const char **argv)
1248 struct perf_evlist *evlist = perf_evlist__new();
1249 struct perf_evsel *evsel;
1251 unsigned long before;
1252 const bool forks = argc > 0;
1254 if (evlist == NULL) {
1255 fprintf(trace->output, "Not enough memory to run!\n");
1259 if (perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_enter", trace__sys_enter) ||
1260 perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit)) {
1261 fprintf(trace->output, "Couldn't read the raw_syscalls tracepoints information!\n");
1262 goto out_delete_evlist;
1266 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
1267 trace__sched_stat_runtime)) {
1268 fprintf(trace->output, "Couldn't read the sched_stat_runtime tracepoint information!\n");
1269 goto out_delete_evlist;
1272 err = perf_evlist__create_maps(evlist, &trace->opts.target);
1274 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
1275 goto out_delete_evlist;
1278 err = trace__symbols_init(trace, evlist);
1280 fprintf(trace->output, "Problems initializing symbol libraries!\n");
1281 goto out_delete_maps;
1284 perf_evlist__config(evlist, &trace->opts);
1286 signal(SIGCHLD, sig_handler);
1287 signal(SIGINT, sig_handler);
1290 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
1291 argv, false, false);
1293 fprintf(trace->output, "Couldn't run the workload!\n");
1294 goto out_delete_maps;
1298 err = perf_evlist__open(evlist);
1300 fprintf(trace->output, "Couldn't create the events: %s\n", strerror(errno));
1301 goto out_delete_maps;
1304 err = perf_evlist__mmap(evlist, UINT_MAX, false);
1306 fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
1307 goto out_close_evlist;
1310 perf_evlist__enable(evlist);
1313 perf_evlist__start_workload(evlist);
1315 trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
1317 before = trace->nr_events;
1319 for (i = 0; i < evlist->nr_mmaps; i++) {
1320 union perf_event *event;
1322 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
1323 const u32 type = event->header.type;
1324 tracepoint_handler handler;
1325 struct perf_sample sample;
1329 err = perf_evlist__parse_sample(evlist, event, &sample);
1331 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
1335 if (!trace->full_time && trace->base_time == 0)
1336 trace->base_time = sample.time;
1338 if (type != PERF_RECORD_SAMPLE) {
1339 trace__process_event(trace, &trace->host, event);
1343 evsel = perf_evlist__id2evsel(evlist, sample.id);
1344 if (evsel == NULL) {
1345 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
1349 if (sample.raw_data == NULL) {
1350 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
1351 perf_evsel__name(evsel), sample.tid,
1352 sample.cpu, sample.raw_size);
1356 handler = evsel->handler.func;
1357 handler(trace, evsel, &sample);
1360 goto out_unmap_evlist;
1364 if (trace->nr_events == before) {
1366 goto out_unmap_evlist;
1368 poll(evlist->pollfd, evlist->nr_fds, -1);
1372 perf_evlist__disable(evlist);
1377 perf_evlist__munmap(evlist);
1379 perf_evlist__close(evlist);
1381 perf_evlist__delete_maps(evlist);
1383 perf_evlist__delete(evlist);
1388 static int trace__replay(struct trace *trace)
1390 const struct perf_evsel_str_handler handlers[] = {
1391 { "raw_syscalls:sys_enter", trace__sys_enter, },
1392 { "raw_syscalls:sys_exit", trace__sys_exit, },
1395 struct perf_session *session;
1398 trace->tool.sample = trace__process_sample;
1399 trace->tool.mmap = perf_event__process_mmap;
1400 trace->tool.mmap2 = perf_event__process_mmap2;
1401 trace->tool.comm = perf_event__process_comm;
1402 trace->tool.exit = perf_event__process_exit;
1403 trace->tool.fork = perf_event__process_fork;
1404 trace->tool.attr = perf_event__process_attr;
1405 trace->tool.tracing_data = perf_event__process_tracing_data;
1406 trace->tool.build_id = perf_event__process_build_id;
1408 trace->tool.ordered_samples = true;
1409 trace->tool.ordering_requires_timestamps = true;
1411 /* add tid to output */
1412 trace->multiple_threads = true;
1414 if (symbol__init() < 0)
1417 session = perf_session__new(input_name, O_RDONLY, 0, false,
1419 if (session == NULL)
1422 err = perf_session__set_tracepoints_handlers(session, handlers);
1426 if (!perf_session__has_tp(session, "raw_syscalls:sys_enter")) {
1427 pr_err("Data file does not have raw_syscalls:sys_enter events\n");
1431 if (!perf_session__has_tp(session, "raw_syscalls:sys_exit")) {
1432 pr_err("Data file does not have raw_syscalls:sys_exit events\n");
1436 err = parse_target_str(trace);
1442 err = perf_session__process_events(session, &trace->tool);
1444 pr_err("Failed to process events, error %d", err);
1447 perf_session__delete(session);
1452 static size_t trace__fprintf_threads_header(FILE *fp)
1456 printed = fprintf(fp, "\n _____________________________________________________________________\n");
1457 printed += fprintf(fp," __) Summary of events (__\n\n");
1458 printed += fprintf(fp," [ task - pid ] [ events ] [ ratio ] [ runtime ]\n");
1459 printed += fprintf(fp," _____________________________________________________________________\n\n");
1464 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
1466 size_t printed = trace__fprintf_threads_header(fp);
1469 for (nd = rb_first(&trace->host.threads); nd; nd = rb_next(nd)) {
1470 struct thread *thread = rb_entry(nd, struct thread, rb_node);
1471 struct thread_trace *ttrace = thread->priv;
1478 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
1480 color = PERF_COLOR_NORMAL;
1482 color = PERF_COLOR_RED;
1483 else if (ratio > 25.0)
1484 color = PERF_COLOR_GREEN;
1485 else if (ratio > 5.0)
1486 color = PERF_COLOR_YELLOW;
1488 printed += color_fprintf(fp, color, "%20s", thread->comm);
1489 printed += fprintf(fp, " - %-5d :%11lu [", thread->tid, ttrace->nr_events);
1490 printed += color_fprintf(fp, color, "%5.1f%%", ratio);
1491 printed += fprintf(fp, " ] %10.3f ms\n", ttrace->runtime_ms);
1497 static int trace__set_duration(const struct option *opt, const char *str,
1498 int unset __maybe_unused)
1500 struct trace *trace = opt->value;
1502 trace->duration_filter = atof(str);
1506 static int trace__open_output(struct trace *trace, const char *filename)
1510 if (!stat(filename, &st) && st.st_size) {
1511 char oldname[PATH_MAX];
1513 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
1515 rename(filename, oldname);
1518 trace->output = fopen(filename, "w");
1520 return trace->output == NULL ? -errno : 0;
1523 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
1525 const char * const trace_usage[] = {
1526 "perf trace [<options>] [<command>]",
1527 "perf trace [<options>] -- <command> [<options>]",
1530 struct trace trace = {
1531 .audit_machine = audit_detect_machine(),
1540 .user_freq = UINT_MAX,
1541 .user_interval = ULLONG_MAX,
1548 const char *output_name = NULL;
1549 const char *ev_qualifier_str = NULL;
1550 const struct option trace_options[] = {
1551 OPT_BOOLEAN(0, "comm", &trace.show_comm,
1552 "show the thread COMM next to its id"),
1553 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
1554 "list of events to trace"),
1555 OPT_STRING('o', "output", &output_name, "file", "output file name"),
1556 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
1557 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
1558 "trace events on existing process id"),
1559 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
1560 "trace events on existing thread id"),
1561 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
1562 "system-wide collection from all CPUs"),
1563 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
1564 "list of cpus to monitor"),
1565 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
1566 "child tasks do not inherit counters"),
1567 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
1568 "number of mmap data pages",
1569 perf_evlist__parse_mmap_pages),
1570 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
1572 OPT_CALLBACK(0, "duration", &trace, "float",
1573 "show only events with duration > N.M ms",
1574 trace__set_duration),
1575 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
1576 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
1577 OPT_BOOLEAN('T', "time", &trace.full_time,
1578 "Show full timestamp, not time relative to first start"),
1584 argc = parse_options(argc, argv, trace_options, trace_usage, 0);
1586 if (output_name != NULL) {
1587 err = trace__open_output(&trace, output_name);
1589 perror("failed to create output file");
1594 if (ev_qualifier_str != NULL) {
1595 const char *s = ev_qualifier_str;
1597 trace.not_ev_qualifier = *s == '!';
1598 if (trace.not_ev_qualifier)
1600 trace.ev_qualifier = strlist__new(true, s);
1601 if (trace.ev_qualifier == NULL) {
1602 fputs("Not enough memory to parse event qualifier",
1609 err = perf_target__validate(&trace.opts.target);
1611 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
1612 fprintf(trace.output, "%s", bf);
1616 err = perf_target__parse_uid(&trace.opts.target);
1618 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
1619 fprintf(trace.output, "%s", bf);
1623 if (!argc && perf_target__none(&trace.opts.target))
1624 trace.opts.target.system_wide = true;
1627 err = trace__replay(&trace);
1629 err = trace__run(&trace, argc, argv);
1631 if (trace.sched && !err)
1632 trace__fprintf_thread_summary(&trace, trace.output);
1635 if (output_name != NULL)
1636 fclose(trace.output);