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"
13 #include "util/stat.h"
14 #include "trace-event.h"
15 #include "util/parse-events.h"
19 #include <sys/eventfd.h>
21 #include <linux/futex.h>
23 /* For older distros: */
25 # define MAP_STACK 0x20000
29 # define MADV_HWPOISON 100
32 #ifndef MADV_MERGEABLE
33 # define MADV_MERGEABLE 12
36 #ifndef MADV_UNMERGEABLE
37 # define MADV_UNMERGEABLE 13
41 # define EFD_SEMAPHORE 1
47 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
48 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
52 #define TP_UINT_FIELD(bits) \
53 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
56 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
65 #define TP_UINT_FIELD__SWAPPED(bits) \
66 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
69 memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
70 return bswap_##bits(value);\
73 TP_UINT_FIELD__SWAPPED(16);
74 TP_UINT_FIELD__SWAPPED(32);
75 TP_UINT_FIELD__SWAPPED(64);
77 static int tp_field__init_uint(struct tp_field *field,
78 struct format_field *format_field,
81 field->offset = format_field->offset;
83 switch (format_field->size) {
85 field->integer = tp_field__u8;
88 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
91 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
94 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
103 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
105 return sample->raw_data + field->offset;
108 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
110 field->offset = format_field->offset;
111 field->pointer = tp_field__ptr;
118 struct tp_field args, ret;
122 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
123 struct tp_field *field,
126 struct format_field *format_field = perf_evsel__field(evsel, name);
128 if (format_field == NULL)
131 return tp_field__init_uint(field, format_field, evsel->needs_swap);
134 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
135 ({ struct syscall_tp *sc = evsel->priv;\
136 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
138 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
139 struct tp_field *field,
142 struct format_field *format_field = perf_evsel__field(evsel, name);
144 if (format_field == NULL)
147 return tp_field__init_ptr(field, format_field);
150 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
151 ({ struct syscall_tp *sc = evsel->priv;\
152 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
154 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
157 perf_evsel__delete(evsel);
160 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
162 evsel->priv = malloc(sizeof(struct syscall_tp));
163 if (evsel->priv != NULL) {
164 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
167 evsel->handler = handler;
178 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
180 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
182 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
184 evsel = perf_evsel__newtp("syscalls", direction);
187 if (perf_evsel__init_syscall_tp(evsel, handler))
194 perf_evsel__delete_priv(evsel);
198 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
199 ({ struct syscall_tp *fields = evsel->priv; \
200 fields->name.integer(&fields->name, sample); })
202 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
203 ({ struct syscall_tp *fields = evsel->priv; \
204 fields->name.pointer(&fields->name, sample); })
206 static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
207 void *sys_enter_handler,
208 void *sys_exit_handler)
211 struct perf_evsel *sys_enter, *sys_exit;
213 sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
214 if (sys_enter == NULL)
217 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
218 goto out_delete_sys_enter;
220 sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
221 if (sys_exit == NULL)
222 goto out_delete_sys_enter;
224 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
225 goto out_delete_sys_exit;
227 perf_evlist__add(evlist, sys_enter);
228 perf_evlist__add(evlist, sys_exit);
235 perf_evsel__delete_priv(sys_exit);
236 out_delete_sys_enter:
237 perf_evsel__delete_priv(sys_enter);
244 struct thread *thread;
254 const char **entries;
257 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
258 .nr_entries = ARRAY_SIZE(array), \
262 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
264 .nr_entries = ARRAY_SIZE(array), \
268 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
270 struct syscall_arg *arg)
272 struct strarray *sa = arg->parm;
273 int idx = arg->val - sa->offset;
275 if (idx < 0 || idx >= sa->nr_entries)
276 return scnprintf(bf, size, intfmt, arg->val);
278 return scnprintf(bf, size, "%s", sa->entries[idx]);
281 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
282 struct syscall_arg *arg)
284 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
287 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
289 #if defined(__i386__) || defined(__x86_64__)
291 * FIXME: Make this available to all arches as soon as the ioctl beautifier
292 * gets rewritten to support all arches.
294 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
295 struct syscall_arg *arg)
297 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
300 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
301 #endif /* defined(__i386__) || defined(__x86_64__) */
303 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
304 struct syscall_arg *arg);
306 #define SCA_FD syscall_arg__scnprintf_fd
308 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
309 struct syscall_arg *arg)
314 return scnprintf(bf, size, "CWD");
316 return syscall_arg__scnprintf_fd(bf, size, arg);
319 #define SCA_FDAT syscall_arg__scnprintf_fd_at
321 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
322 struct syscall_arg *arg);
324 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
326 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
327 struct syscall_arg *arg)
329 return scnprintf(bf, size, "%#lx", arg->val);
332 #define SCA_HEX syscall_arg__scnprintf_hex
334 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
335 struct syscall_arg *arg)
337 int printed = 0, prot = arg->val;
339 if (prot == PROT_NONE)
340 return scnprintf(bf, size, "NONE");
341 #define P_MMAP_PROT(n) \
342 if (prot & PROT_##n) { \
343 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
353 P_MMAP_PROT(GROWSDOWN);
354 P_MMAP_PROT(GROWSUP);
358 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
363 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
365 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
366 struct syscall_arg *arg)
368 int printed = 0, flags = arg->val;
370 #define P_MMAP_FLAG(n) \
371 if (flags & MAP_##n) { \
372 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
377 P_MMAP_FLAG(PRIVATE);
381 P_MMAP_FLAG(ANONYMOUS);
382 P_MMAP_FLAG(DENYWRITE);
383 P_MMAP_FLAG(EXECUTABLE);
386 P_MMAP_FLAG(GROWSDOWN);
388 P_MMAP_FLAG(HUGETLB);
391 P_MMAP_FLAG(NONBLOCK);
392 P_MMAP_FLAG(NORESERVE);
393 P_MMAP_FLAG(POPULATE);
395 #ifdef MAP_UNINITIALIZED
396 P_MMAP_FLAG(UNINITIALIZED);
401 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
406 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
408 static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
409 struct syscall_arg *arg)
411 int printed = 0, flags = arg->val;
413 #define P_MREMAP_FLAG(n) \
414 if (flags & MREMAP_##n) { \
415 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
416 flags &= ~MREMAP_##n; \
419 P_MREMAP_FLAG(MAYMOVE);
421 P_MREMAP_FLAG(FIXED);
426 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
431 #define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
433 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
434 struct syscall_arg *arg)
436 int behavior = arg->val;
439 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
442 P_MADV_BHV(SEQUENTIAL);
443 P_MADV_BHV(WILLNEED);
444 P_MADV_BHV(DONTNEED);
446 P_MADV_BHV(DONTFORK);
448 P_MADV_BHV(HWPOISON);
449 #ifdef MADV_SOFT_OFFLINE
450 P_MADV_BHV(SOFT_OFFLINE);
452 P_MADV_BHV(MERGEABLE);
453 P_MADV_BHV(UNMERGEABLE);
455 P_MADV_BHV(HUGEPAGE);
457 #ifdef MADV_NOHUGEPAGE
458 P_MADV_BHV(NOHUGEPAGE);
461 P_MADV_BHV(DONTDUMP);
470 return scnprintf(bf, size, "%#x", behavior);
473 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
475 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
476 struct syscall_arg *arg)
478 int printed = 0, op = arg->val;
481 return scnprintf(bf, size, "NONE");
483 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
484 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
499 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
504 #define SCA_FLOCK syscall_arg__scnprintf_flock
506 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
508 enum syscall_futex_args {
509 SCF_UADDR = (1 << 0),
512 SCF_TIMEOUT = (1 << 3),
513 SCF_UADDR2 = (1 << 4),
517 int cmd = op & FUTEX_CMD_MASK;
521 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
522 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
523 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
524 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
525 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
526 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
527 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
528 P_FUTEX_OP(WAKE_OP); break;
529 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
530 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
531 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
532 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
533 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
534 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
535 default: printed = scnprintf(bf, size, "%#x", cmd); break;
538 if (op & FUTEX_PRIVATE_FLAG)
539 printed += scnprintf(bf + printed, size - printed, "|PRIV");
541 if (op & FUTEX_CLOCK_REALTIME)
542 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
547 #define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
549 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
550 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
552 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
553 static DEFINE_STRARRAY(itimers);
555 static const char *whences[] = { "SET", "CUR", "END",
563 static DEFINE_STRARRAY(whences);
565 static const char *fcntl_cmds[] = {
566 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
567 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
568 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
571 static DEFINE_STRARRAY(fcntl_cmds);
573 static const char *rlimit_resources[] = {
574 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
575 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
578 static DEFINE_STRARRAY(rlimit_resources);
580 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
581 static DEFINE_STRARRAY(sighow);
583 static const char *clockid[] = {
584 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
585 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
587 static DEFINE_STRARRAY(clockid);
589 static const char *socket_families[] = {
590 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
591 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
592 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
593 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
594 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
595 "ALG", "NFC", "VSOCK",
597 static DEFINE_STRARRAY(socket_families);
599 #ifndef SOCK_TYPE_MASK
600 #define SOCK_TYPE_MASK 0xf
603 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
604 struct syscall_arg *arg)
608 flags = type & ~SOCK_TYPE_MASK;
610 type &= SOCK_TYPE_MASK;
612 * Can't use a strarray, MIPS may override for ABI reasons.
615 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
620 P_SK_TYPE(SEQPACKET);
625 printed = scnprintf(bf, size, "%#x", type);
628 #define P_SK_FLAG(n) \
629 if (flags & SOCK_##n) { \
630 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
631 flags &= ~SOCK_##n; \
639 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
644 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
647 #define MSG_PROBE 0x10
649 #ifndef MSG_WAITFORONE
650 #define MSG_WAITFORONE 0x10000
652 #ifndef MSG_SENDPAGE_NOTLAST
653 #define MSG_SENDPAGE_NOTLAST 0x20000
656 #define MSG_FASTOPEN 0x20000000
659 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
660 struct syscall_arg *arg)
662 int printed = 0, flags = arg->val;
665 return scnprintf(bf, size, "NONE");
666 #define P_MSG_FLAG(n) \
667 if (flags & MSG_##n) { \
668 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
674 P_MSG_FLAG(DONTROUTE);
679 P_MSG_FLAG(DONTWAIT);
686 P_MSG_FLAG(ERRQUEUE);
687 P_MSG_FLAG(NOSIGNAL);
689 P_MSG_FLAG(WAITFORONE);
690 P_MSG_FLAG(SENDPAGE_NOTLAST);
691 P_MSG_FLAG(FASTOPEN);
692 P_MSG_FLAG(CMSG_CLOEXEC);
696 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
701 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
703 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
704 struct syscall_arg *arg)
709 if (mode == F_OK) /* 0 */
710 return scnprintf(bf, size, "F");
712 if (mode & n##_OK) { \
713 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
723 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
728 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
730 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
731 struct syscall_arg *arg)
733 int printed = 0, flags = arg->val;
735 if (!(flags & O_CREAT))
736 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
739 return scnprintf(bf, size, "RDONLY");
741 if (flags & O_##n) { \
742 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
766 if ((flags & O_SYNC) == O_SYNC)
767 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
779 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
784 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
786 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
787 struct syscall_arg *arg)
789 int printed = 0, flags = arg->val;
792 return scnprintf(bf, size, "NONE");
794 if (flags & EFD_##n) { \
795 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
805 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
810 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
812 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
813 struct syscall_arg *arg)
815 int printed = 0, flags = arg->val;
818 if (flags & O_##n) { \
819 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
828 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
833 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
835 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
840 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
883 return scnprintf(bf, size, "%#x", sig);
886 #define SCA_SIGNUM syscall_arg__scnprintf_signum
888 #if defined(__i386__) || defined(__x86_64__)
890 * FIXME: Make this available to all arches.
892 #define TCGETS 0x5401
894 static const char *tioctls[] = {
895 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
896 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
897 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
898 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
899 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
900 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
901 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
902 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
903 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
904 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
905 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
906 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
907 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
908 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
909 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
912 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
913 #endif /* defined(__i386__) || defined(__x86_64__) */
915 #define STRARRAY(arg, name, array) \
916 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
917 .arg_parm = { [arg] = &strarray__##array, }
919 static struct syscall_fmt {
922 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
928 { .name = "access", .errmsg = true,
929 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
930 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
931 { .name = "brk", .hexret = true,
932 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
933 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
934 { .name = "close", .errmsg = true,
935 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
936 { .name = "connect", .errmsg = true, },
937 { .name = "dup", .errmsg = true,
938 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
939 { .name = "dup2", .errmsg = true,
940 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
941 { .name = "dup3", .errmsg = true,
942 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
943 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
944 { .name = "eventfd2", .errmsg = true,
945 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
946 { .name = "faccessat", .errmsg = true,
947 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
948 { .name = "fadvise64", .errmsg = true,
949 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
950 { .name = "fallocate", .errmsg = true,
951 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
952 { .name = "fchdir", .errmsg = true,
953 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
954 { .name = "fchmod", .errmsg = true,
955 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
956 { .name = "fchmodat", .errmsg = true,
957 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
958 { .name = "fchown", .errmsg = true,
959 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
960 { .name = "fchownat", .errmsg = true,
961 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
962 { .name = "fcntl", .errmsg = true,
963 .arg_scnprintf = { [0] = SCA_FD, /* fd */
964 [1] = SCA_STRARRAY, /* cmd */ },
965 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
966 { .name = "fdatasync", .errmsg = true,
967 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
968 { .name = "flock", .errmsg = true,
969 .arg_scnprintf = { [0] = SCA_FD, /* fd */
970 [1] = SCA_FLOCK, /* cmd */ }, },
971 { .name = "fsetxattr", .errmsg = true,
972 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
973 { .name = "fstat", .errmsg = true, .alias = "newfstat",
974 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
975 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
976 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
977 { .name = "fstatfs", .errmsg = true,
978 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
979 { .name = "fsync", .errmsg = true,
980 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
981 { .name = "ftruncate", .errmsg = true,
982 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
983 { .name = "futex", .errmsg = true,
984 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
985 { .name = "futimesat", .errmsg = true,
986 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
987 { .name = "getdents", .errmsg = true,
988 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
989 { .name = "getdents64", .errmsg = true,
990 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
991 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
992 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
993 { .name = "ioctl", .errmsg = true,
994 .arg_scnprintf = { [0] = SCA_FD, /* fd */
995 #if defined(__i386__) || defined(__x86_64__)
997 * FIXME: Make this available to all arches.
999 [1] = SCA_STRHEXARRAY, /* cmd */
1000 [2] = SCA_HEX, /* arg */ },
1001 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
1003 [2] = SCA_HEX, /* arg */ }, },
1005 { .name = "kill", .errmsg = true,
1006 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1007 { .name = "linkat", .errmsg = true,
1008 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1009 { .name = "lseek", .errmsg = true,
1010 .arg_scnprintf = { [0] = SCA_FD, /* fd */
1011 [2] = SCA_STRARRAY, /* whence */ },
1012 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
1013 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
1014 { .name = "madvise", .errmsg = true,
1015 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1016 [2] = SCA_MADV_BHV, /* behavior */ }, },
1017 { .name = "mkdirat", .errmsg = true,
1018 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1019 { .name = "mknodat", .errmsg = true,
1020 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1021 { .name = "mlock", .errmsg = true,
1022 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1023 { .name = "mlockall", .errmsg = true,
1024 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1025 { .name = "mmap", .hexret = true,
1026 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1027 [2] = SCA_MMAP_PROT, /* prot */
1028 [3] = SCA_MMAP_FLAGS, /* flags */
1029 [4] = SCA_FD, /* fd */ }, },
1030 { .name = "mprotect", .errmsg = true,
1031 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1032 [2] = SCA_MMAP_PROT, /* prot */ }, },
1033 { .name = "mremap", .hexret = true,
1034 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1035 [3] = SCA_MREMAP_FLAGS, /* flags */
1036 [4] = SCA_HEX, /* new_addr */ }, },
1037 { .name = "munlock", .errmsg = true,
1038 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1039 { .name = "munmap", .errmsg = true,
1040 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1041 { .name = "name_to_handle_at", .errmsg = true,
1042 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1043 { .name = "newfstatat", .errmsg = true,
1044 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1045 { .name = "open", .errmsg = true,
1046 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1047 { .name = "open_by_handle_at", .errmsg = true,
1048 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1049 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1050 { .name = "openat", .errmsg = true,
1051 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1052 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1053 { .name = "pipe2", .errmsg = true,
1054 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1055 { .name = "poll", .errmsg = true, .timeout = true, },
1056 { .name = "ppoll", .errmsg = true, .timeout = true, },
1057 { .name = "pread", .errmsg = true, .alias = "pread64",
1058 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1059 { .name = "preadv", .errmsg = true, .alias = "pread",
1060 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1061 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1062 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
1063 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1064 { .name = "pwritev", .errmsg = true,
1065 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1066 { .name = "read", .errmsg = true,
1067 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1068 { .name = "readlinkat", .errmsg = true,
1069 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1070 { .name = "readv", .errmsg = true,
1071 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1072 { .name = "recvfrom", .errmsg = true,
1073 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1074 { .name = "recvmmsg", .errmsg = true,
1075 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1076 { .name = "recvmsg", .errmsg = true,
1077 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1078 { .name = "renameat", .errmsg = true,
1079 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1080 { .name = "rt_sigaction", .errmsg = true,
1081 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1082 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
1083 { .name = "rt_sigqueueinfo", .errmsg = true,
1084 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1085 { .name = "rt_tgsigqueueinfo", .errmsg = true,
1086 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1087 { .name = "select", .errmsg = true, .timeout = true, },
1088 { .name = "sendmmsg", .errmsg = true,
1089 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1090 { .name = "sendmsg", .errmsg = true,
1091 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1092 { .name = "sendto", .errmsg = true,
1093 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1094 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1095 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1096 { .name = "shutdown", .errmsg = true,
1097 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1098 { .name = "socket", .errmsg = true,
1099 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1100 [1] = SCA_SK_TYPE, /* type */ },
1101 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1102 { .name = "socketpair", .errmsg = true,
1103 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1104 [1] = SCA_SK_TYPE, /* type */ },
1105 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1106 { .name = "stat", .errmsg = true, .alias = "newstat", },
1107 { .name = "symlinkat", .errmsg = true,
1108 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1109 { .name = "tgkill", .errmsg = true,
1110 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1111 { .name = "tkill", .errmsg = true,
1112 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1113 { .name = "uname", .errmsg = true, .alias = "newuname", },
1114 { .name = "unlinkat", .errmsg = true,
1115 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1116 { .name = "utimensat", .errmsg = true,
1117 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
1118 { .name = "write", .errmsg = true,
1119 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1120 { .name = "writev", .errmsg = true,
1121 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1124 static int syscall_fmt__cmp(const void *name, const void *fmtp)
1126 const struct syscall_fmt *fmt = fmtp;
1127 return strcmp(name, fmt->name);
1130 static struct syscall_fmt *syscall_fmt__find(const char *name)
1132 const int nmemb = ARRAY_SIZE(syscall_fmts);
1133 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1137 struct event_format *tp_format;
1141 struct syscall_fmt *fmt;
1142 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1146 static size_t fprintf_duration(unsigned long t, FILE *fp)
1148 double duration = (double)t / NSEC_PER_MSEC;
1149 size_t printed = fprintf(fp, "(");
1151 if (duration >= 1.0)
1152 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1153 else if (duration >= 0.01)
1154 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1156 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1157 return printed + fprintf(fp, "): ");
1160 struct thread_trace {
1164 unsigned long nr_events;
1165 unsigned long pfmaj, pfmin;
1173 struct intlist *syscall_stats;
1176 static struct thread_trace *thread_trace__new(void)
1178 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1181 ttrace->paths.max = -1;
1183 ttrace->syscall_stats = intlist__new(NULL);
1188 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1190 struct thread_trace *ttrace;
1195 if (thread__priv(thread) == NULL)
1196 thread__set_priv(thread, thread_trace__new());
1198 if (thread__priv(thread) == NULL)
1201 ttrace = thread__priv(thread);
1202 ++ttrace->nr_events;
1206 color_fprintf(fp, PERF_COLOR_RED,
1207 "WARNING: not enough memory, dropping samples!\n");
1211 #define TRACE_PFMAJ (1 << 0)
1212 #define TRACE_PFMIN (1 << 1)
1215 struct perf_tool tool;
1222 struct syscall *table;
1224 struct record_opts opts;
1225 struct perf_evlist *evlist;
1226 struct machine *host;
1227 struct thread *current;
1230 unsigned long nr_events;
1231 struct strlist *ev_qualifier;
1232 const char *last_vfs_getname;
1233 struct intlist *tid_list;
1234 struct intlist *pid_list;
1239 double duration_filter;
1245 bool not_ev_qualifier;
1249 bool multiple_threads;
1253 bool show_tool_stats;
1254 bool trace_syscalls;
1258 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1260 struct thread_trace *ttrace = thread__priv(thread);
1262 if (fd > ttrace->paths.max) {
1263 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1268 if (ttrace->paths.max != -1) {
1269 memset(npath + ttrace->paths.max + 1, 0,
1270 (fd - ttrace->paths.max) * sizeof(char *));
1272 memset(npath, 0, (fd + 1) * sizeof(char *));
1275 ttrace->paths.table = npath;
1276 ttrace->paths.max = fd;
1279 ttrace->paths.table[fd] = strdup(pathname);
1281 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1284 static int thread__read_fd_path(struct thread *thread, int fd)
1286 char linkname[PATH_MAX], pathname[PATH_MAX];
1290 if (thread->pid_ == thread->tid) {
1291 scnprintf(linkname, sizeof(linkname),
1292 "/proc/%d/fd/%d", thread->pid_, fd);
1294 scnprintf(linkname, sizeof(linkname),
1295 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1298 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1301 ret = readlink(linkname, pathname, sizeof(pathname));
1303 if (ret < 0 || ret > st.st_size)
1306 pathname[ret] = '\0';
1307 return trace__set_fd_pathname(thread, fd, pathname);
1310 static const char *thread__fd_path(struct thread *thread, int fd,
1311 struct trace *trace)
1313 struct thread_trace *ttrace = thread__priv(thread);
1321 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1324 ++trace->stats.proc_getname;
1325 if (thread__read_fd_path(thread, fd))
1329 return ttrace->paths.table[fd];
1332 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1333 struct syscall_arg *arg)
1336 size_t printed = scnprintf(bf, size, "%d", fd);
1337 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1340 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1345 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1346 struct syscall_arg *arg)
1349 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1350 struct thread_trace *ttrace = thread__priv(arg->thread);
1352 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1353 zfree(&ttrace->paths.table[fd]);
1358 static bool trace__filter_duration(struct trace *trace, double t)
1360 return t < (trace->duration_filter * NSEC_PER_MSEC);
1363 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1365 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1367 return fprintf(fp, "%10.3f ", ts);
1370 static bool done = false;
1371 static bool interrupted = false;
1373 static void sig_handler(int sig)
1376 interrupted = sig == SIGINT;
1379 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1380 u64 duration, u64 tstamp, FILE *fp)
1382 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1383 printed += fprintf_duration(duration, fp);
1385 if (trace->multiple_threads) {
1386 if (trace->show_comm)
1387 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1388 printed += fprintf(fp, "%d ", thread->tid);
1394 static int trace__process_event(struct trace *trace, struct machine *machine,
1395 union perf_event *event, struct perf_sample *sample)
1399 switch (event->header.type) {
1400 case PERF_RECORD_LOST:
1401 color_fprintf(trace->output, PERF_COLOR_RED,
1402 "LOST %" PRIu64 " events!\n", event->lost.lost);
1403 ret = machine__process_lost_event(machine, event, sample);
1405 ret = machine__process_event(machine, event, sample);
1412 static int trace__tool_process(struct perf_tool *tool,
1413 union perf_event *event,
1414 struct perf_sample *sample,
1415 struct machine *machine)
1417 struct trace *trace = container_of(tool, struct trace, tool);
1418 return trace__process_event(trace, machine, event, sample);
1421 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1423 int err = symbol__init(NULL);
1428 trace->host = machine__new_host();
1429 if (trace->host == NULL)
1432 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1433 evlist->threads, trace__tool_process, false);
1440 static int syscall__set_arg_fmts(struct syscall *sc)
1442 struct format_field *field;
1445 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
1446 if (sc->arg_scnprintf == NULL)
1450 sc->arg_parm = sc->fmt->arg_parm;
1452 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
1453 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1454 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1455 else if (field->flags & FIELD_IS_POINTER)
1456 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1463 static int trace__read_syscall_info(struct trace *trace, int id)
1467 const char *name = audit_syscall_to_name(id, trace->audit.machine);
1472 if (id > trace->syscalls.max) {
1473 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1475 if (nsyscalls == NULL)
1478 if (trace->syscalls.max != -1) {
1479 memset(nsyscalls + trace->syscalls.max + 1, 0,
1480 (id - trace->syscalls.max) * sizeof(*sc));
1482 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1485 trace->syscalls.table = nsyscalls;
1486 trace->syscalls.max = id;
1489 sc = trace->syscalls.table + id;
1492 if (trace->ev_qualifier) {
1493 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1495 if (!(in ^ trace->not_ev_qualifier)) {
1496 sc->filtered = true;
1498 * No need to do read tracepoint information since this will be
1505 sc->fmt = syscall_fmt__find(sc->name);
1507 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1508 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1510 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1511 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1512 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1515 if (sc->tp_format == NULL)
1518 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1520 return syscall__set_arg_fmts(sc);
1524 * args is to be interpreted as a series of longs but we need to handle
1525 * 8-byte unaligned accesses. args points to raw_data within the event
1526 * and raw_data is guaranteed to be 8-byte unaligned because it is
1527 * preceded by raw_size which is a u32. So we need to copy args to a temp
1528 * variable to read it. Most notably this avoids extended load instructions
1529 * on unaligned addresses
1532 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1533 unsigned char *args, struct trace *trace,
1534 struct thread *thread)
1540 if (sc->tp_format != NULL) {
1541 struct format_field *field;
1543 struct syscall_arg arg = {
1550 for (field = sc->tp_format->format.fields->next; field;
1551 field = field->next, ++arg.idx, bit <<= 1) {
1555 /* special care for unaligned accesses */
1556 p = args + sizeof(unsigned long) * arg.idx;
1557 memcpy(&val, p, sizeof(val));
1560 * Suppress this argument if its value is zero and
1561 * and we don't have a string associated in an
1565 !(sc->arg_scnprintf &&
1566 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1567 sc->arg_parm[arg.idx]))
1570 printed += scnprintf(bf + printed, size - printed,
1571 "%s%s: ", printed ? ", " : "", field->name);
1572 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1575 arg.parm = sc->arg_parm[arg.idx];
1576 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1577 size - printed, &arg);
1579 printed += scnprintf(bf + printed, size - printed,
1587 /* special care for unaligned accesses */
1588 p = args + sizeof(unsigned long) * i;
1589 memcpy(&val, p, sizeof(val));
1590 printed += scnprintf(bf + printed, size - printed,
1592 printed ? ", " : "", i, val);
1600 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1601 union perf_event *event,
1602 struct perf_sample *sample);
1604 static struct syscall *trace__syscall_info(struct trace *trace,
1605 struct perf_evsel *evsel, int id)
1611 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1612 * before that, leaving at a higher verbosity level till that is
1613 * explained. Reproduced with plain ftrace with:
1615 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1616 * grep "NR -1 " /t/trace_pipe
1618 * After generating some load on the machine.
1622 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1623 id, perf_evsel__name(evsel), ++n);
1628 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1629 trace__read_syscall_info(trace, id))
1632 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1635 return &trace->syscalls.table[id];
1639 fprintf(trace->output, "Problems reading syscall %d", id);
1640 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1641 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1642 fputs(" information\n", trace->output);
1647 static void thread__update_stats(struct thread_trace *ttrace,
1648 int id, struct perf_sample *sample)
1650 struct int_node *inode;
1651 struct stats *stats;
1654 inode = intlist__findnew(ttrace->syscall_stats, id);
1658 stats = inode->priv;
1659 if (stats == NULL) {
1660 stats = malloc(sizeof(struct stats));
1664 inode->priv = stats;
1667 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1668 duration = sample->time - ttrace->entry_time;
1670 update_stats(stats, duration);
1673 static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1675 struct thread_trace *ttrace;
1679 if (trace->current == NULL)
1682 ttrace = thread__priv(trace->current);
1684 if (!ttrace->entry_pending)
1687 duration = sample->time - ttrace->entry_time;
1689 printed = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1690 printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1691 ttrace->entry_pending = false;
1696 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1697 union perf_event *event __maybe_unused,
1698 struct perf_sample *sample)
1703 struct thread *thread;
1704 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1705 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1706 struct thread_trace *ttrace;
1714 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1715 ttrace = thread__trace(thread, trace->output);
1719 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1721 if (ttrace->entry_str == NULL) {
1722 ttrace->entry_str = malloc(1024);
1723 if (!ttrace->entry_str)
1727 printed += trace__printf_interrupted_entry(trace, sample);
1729 ttrace->entry_time = sample->time;
1730 msg = ttrace->entry_str;
1731 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1733 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1734 args, trace, thread);
1737 if (!trace->duration_filter && !trace->summary_only) {
1738 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1739 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1742 ttrace->entry_pending = true;
1744 trace->current = thread;
1749 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1750 union perf_event *event __maybe_unused,
1751 struct perf_sample *sample)
1755 struct thread *thread;
1756 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1757 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1758 struct thread_trace *ttrace;
1766 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1767 ttrace = thread__trace(thread, trace->output);
1772 thread__update_stats(ttrace, id, sample);
1774 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1776 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1777 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1778 trace->last_vfs_getname = NULL;
1779 ++trace->stats.vfs_getname;
1782 ttrace->exit_time = sample->time;
1784 if (ttrace->entry_time) {
1785 duration = sample->time - ttrace->entry_time;
1786 if (trace__filter_duration(trace, duration))
1788 } else if (trace->duration_filter)
1791 if (trace->summary_only)
1794 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1796 if (ttrace->entry_pending) {
1797 fprintf(trace->output, "%-70s", ttrace->entry_str);
1799 fprintf(trace->output, " ... [");
1800 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1801 fprintf(trace->output, "]: %s()", sc->name);
1804 if (sc->fmt == NULL) {
1806 fprintf(trace->output, ") = %ld", ret);
1807 } else if (ret < 0 && sc->fmt->errmsg) {
1808 char bf[STRERR_BUFSIZE];
1809 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1810 *e = audit_errno_to_name(-ret);
1812 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1813 } else if (ret == 0 && sc->fmt->timeout)
1814 fprintf(trace->output, ") = 0 Timeout");
1815 else if (sc->fmt->hexret)
1816 fprintf(trace->output, ") = %#lx", ret);
1820 fputc('\n', trace->output);
1822 ttrace->entry_pending = false;
1827 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1828 union perf_event *event __maybe_unused,
1829 struct perf_sample *sample)
1831 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1835 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1836 union perf_event *event __maybe_unused,
1837 struct perf_sample *sample)
1839 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1840 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1841 struct thread *thread = machine__findnew_thread(trace->host,
1844 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1849 ttrace->runtime_ms += runtime_ms;
1850 trace->runtime_ms += runtime_ms;
1854 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1856 perf_evsel__strval(evsel, sample, "comm"),
1857 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1859 perf_evsel__intval(evsel, sample, "vruntime"));
1863 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
1864 union perf_event *event __maybe_unused,
1865 struct perf_sample *sample)
1867 trace__printf_interrupted_entry(trace, sample);
1868 trace__fprintf_tstamp(trace, sample->time, trace->output);
1870 if (trace->trace_syscalls)
1871 fprintf(trace->output, "( ): ");
1873 fprintf(trace->output, "%s:", evsel->name);
1875 if (evsel->tp_format) {
1876 event_format__fprintf(evsel->tp_format, sample->cpu,
1877 sample->raw_data, sample->raw_size,
1881 fprintf(trace->output, ")\n");
1885 static void print_location(FILE *f, struct perf_sample *sample,
1886 struct addr_location *al,
1887 bool print_dso, bool print_sym)
1890 if ((verbose || print_dso) && al->map)
1891 fprintf(f, "%s@", al->map->dso->long_name);
1893 if ((verbose || print_sym) && al->sym)
1894 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
1895 al->addr - al->sym->start);
1897 fprintf(f, "0x%" PRIx64, al->addr);
1899 fprintf(f, "0x%" PRIx64, sample->addr);
1902 static int trace__pgfault(struct trace *trace,
1903 struct perf_evsel *evsel,
1904 union perf_event *event,
1905 struct perf_sample *sample)
1907 struct thread *thread;
1908 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1909 struct addr_location al;
1910 char map_type = 'd';
1911 struct thread_trace *ttrace;
1913 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1914 ttrace = thread__trace(thread, trace->output);
1918 if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
1923 if (trace->summary_only)
1926 thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
1929 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1931 fprintf(trace->output, "%sfault [",
1932 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1935 print_location(trace->output, sample, &al, false, true);
1937 fprintf(trace->output, "] => ");
1939 thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
1943 thread__find_addr_location(thread, cpumode,
1944 MAP__FUNCTION, sample->addr, &al);
1952 print_location(trace->output, sample, &al, true, false);
1954 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1959 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1961 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1962 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1965 if (trace->pid_list || trace->tid_list)
1971 static int trace__process_sample(struct perf_tool *tool,
1972 union perf_event *event,
1973 struct perf_sample *sample,
1974 struct perf_evsel *evsel,
1975 struct machine *machine __maybe_unused)
1977 struct trace *trace = container_of(tool, struct trace, tool);
1980 tracepoint_handler handler = evsel->handler;
1982 if (skip_sample(trace, sample))
1985 if (!trace->full_time && trace->base_time == 0)
1986 trace->base_time = sample->time;
1990 handler(trace, evsel, event, sample);
1996 static int parse_target_str(struct trace *trace)
1998 if (trace->opts.target.pid) {
1999 trace->pid_list = intlist__new(trace->opts.target.pid);
2000 if (trace->pid_list == NULL) {
2001 pr_err("Error parsing process id string\n");
2006 if (trace->opts.target.tid) {
2007 trace->tid_list = intlist__new(trace->opts.target.tid);
2008 if (trace->tid_list == NULL) {
2009 pr_err("Error parsing thread id string\n");
2017 static int trace__record(struct trace *trace, int argc, const char **argv)
2019 unsigned int rec_argc, i, j;
2020 const char **rec_argv;
2021 const char * const record_args[] = {
2028 const char * const sc_args[] = { "-e", };
2029 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2030 const char * const majpf_args[] = { "-e", "major-faults" };
2031 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2032 const char * const minpf_args[] = { "-e", "minor-faults" };
2033 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2035 /* +1 is for the event string below */
2036 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2037 majpf_args_nr + minpf_args_nr + argc;
2038 rec_argv = calloc(rec_argc + 1, sizeof(char *));
2040 if (rec_argv == NULL)
2044 for (i = 0; i < ARRAY_SIZE(record_args); i++)
2045 rec_argv[j++] = record_args[i];
2047 if (trace->trace_syscalls) {
2048 for (i = 0; i < sc_args_nr; i++)
2049 rec_argv[j++] = sc_args[i];
2051 /* event string may be different for older kernels - e.g., RHEL6 */
2052 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2053 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2054 else if (is_valid_tracepoint("syscalls:sys_enter"))
2055 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2057 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2062 if (trace->trace_pgfaults & TRACE_PFMAJ)
2063 for (i = 0; i < majpf_args_nr; i++)
2064 rec_argv[j++] = majpf_args[i];
2066 if (trace->trace_pgfaults & TRACE_PFMIN)
2067 for (i = 0; i < minpf_args_nr; i++)
2068 rec_argv[j++] = minpf_args[i];
2070 for (i = 0; i < (unsigned int)argc; i++)
2071 rec_argv[j++] = argv[i];
2073 return cmd_record(j, rec_argv, NULL);
2076 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2078 static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2080 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2084 if (perf_evsel__field(evsel, "pathname") == NULL) {
2085 perf_evsel__delete(evsel);
2089 evsel->handler = trace__vfs_getname;
2090 perf_evlist__add(evlist, evsel);
2093 static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
2096 struct perf_evsel *evsel;
2097 struct perf_event_attr attr = {
2098 .type = PERF_TYPE_SOFTWARE,
2102 attr.config = config;
2103 attr.sample_period = 1;
2105 event_attr_init(&attr);
2107 evsel = perf_evsel__new(&attr);
2111 evsel->handler = trace__pgfault;
2112 perf_evlist__add(evlist, evsel);
2117 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2119 const u32 type = event->header.type;
2120 struct perf_evsel *evsel;
2122 if (!trace->full_time && trace->base_time == 0)
2123 trace->base_time = sample->time;
2125 if (type != PERF_RECORD_SAMPLE) {
2126 trace__process_event(trace, trace->host, event, sample);
2130 evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2131 if (evsel == NULL) {
2132 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2136 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2137 sample->raw_data == NULL) {
2138 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2139 perf_evsel__name(evsel), sample->tid,
2140 sample->cpu, sample->raw_size);
2142 tracepoint_handler handler = evsel->handler;
2143 handler(trace, evsel, event, sample);
2147 static int trace__run(struct trace *trace, int argc, const char **argv)
2149 struct perf_evlist *evlist = trace->evlist;
2151 unsigned long before;
2152 const bool forks = argc > 0;
2153 bool draining = false;
2157 if (trace->trace_syscalls &&
2158 perf_evlist__add_syscall_newtp(evlist, trace__sys_enter,
2160 goto out_error_raw_syscalls;
2162 if (trace->trace_syscalls)
2163 perf_evlist__add_vfs_getname(evlist);
2165 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2166 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
2170 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2171 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2175 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2176 trace__sched_stat_runtime))
2177 goto out_error_sched_stat_runtime;
2179 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2181 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2182 goto out_delete_evlist;
2185 err = trace__symbols_init(trace, evlist);
2187 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2188 goto out_delete_evlist;
2191 perf_evlist__config(evlist, &trace->opts);
2193 signal(SIGCHLD, sig_handler);
2194 signal(SIGINT, sig_handler);
2197 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2200 fprintf(trace->output, "Couldn't run the workload!\n");
2201 goto out_delete_evlist;
2205 err = perf_evlist__open(evlist);
2207 goto out_error_open;
2210 * Better not use !target__has_task() here because we need to cover the
2211 * case where no threads were specified in the command line, but a
2212 * workload was, and in that case we will fill in the thread_map when
2213 * we fork the workload in perf_evlist__prepare_workload.
2215 if (trace->filter_pids.nr > 0)
2216 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2217 else if (evlist->threads->map[0] == -1)
2218 err = perf_evlist__set_filter_pid(evlist, getpid());
2221 printf("err=%d,%s\n", -err, strerror(-err));
2225 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2227 goto out_error_mmap;
2230 perf_evlist__start_workload(evlist);
2232 perf_evlist__enable(evlist);
2234 trace->multiple_threads = evlist->threads->map[0] == -1 ||
2235 evlist->threads->nr > 1 ||
2236 perf_evlist__first(evlist)->attr.inherit;
2238 before = trace->nr_events;
2240 for (i = 0; i < evlist->nr_mmaps; i++) {
2241 union perf_event *event;
2243 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2244 struct perf_sample sample;
2248 err = perf_evlist__parse_sample(evlist, event, &sample);
2250 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2254 trace__handle_event(trace, event, &sample);
2256 perf_evlist__mmap_consume(evlist, i);
2263 if (trace->nr_events == before) {
2264 int timeout = done ? 100 : -1;
2266 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2267 if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2277 perf_evlist__disable(evlist);
2281 trace__fprintf_thread_summary(trace, trace->output);
2283 if (trace->show_tool_stats) {
2284 fprintf(trace->output, "Stats:\n "
2285 " vfs_getname : %" PRIu64 "\n"
2286 " proc_getname: %" PRIu64 "\n",
2287 trace->stats.vfs_getname,
2288 trace->stats.proc_getname);
2293 perf_evlist__delete(evlist);
2294 trace->evlist = NULL;
2295 trace->live = false;
2298 char errbuf[BUFSIZ];
2300 out_error_sched_stat_runtime:
2301 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2304 out_error_raw_syscalls:
2305 debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2309 perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2313 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2316 fprintf(trace->output, "%s\n", errbuf);
2317 goto out_delete_evlist;
2320 fprintf(trace->output, "Not enough memory to run!\n");
2321 goto out_delete_evlist;
2324 static int trace__replay(struct trace *trace)
2326 const struct perf_evsel_str_handler handlers[] = {
2327 { "probe:vfs_getname", trace__vfs_getname, },
2329 struct perf_data_file file = {
2331 .mode = PERF_DATA_MODE_READ,
2333 struct perf_session *session;
2334 struct perf_evsel *evsel;
2337 trace->tool.sample = trace__process_sample;
2338 trace->tool.mmap = perf_event__process_mmap;
2339 trace->tool.mmap2 = perf_event__process_mmap2;
2340 trace->tool.comm = perf_event__process_comm;
2341 trace->tool.exit = perf_event__process_exit;
2342 trace->tool.fork = perf_event__process_fork;
2343 trace->tool.attr = perf_event__process_attr;
2344 trace->tool.tracing_data = perf_event__process_tracing_data;
2345 trace->tool.build_id = perf_event__process_build_id;
2347 trace->tool.ordered_events = true;
2348 trace->tool.ordering_requires_timestamps = true;
2350 /* add tid to output */
2351 trace->multiple_threads = true;
2353 session = perf_session__new(&file, false, &trace->tool);
2354 if (session == NULL)
2357 if (symbol__init(&session->header.env) < 0)
2360 trace->host = &session->machines.host;
2362 err = perf_session__set_tracepoints_handlers(session, handlers);
2366 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2367 "raw_syscalls:sys_enter");
2368 /* older kernels have syscalls tp versus raw_syscalls */
2370 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2371 "syscalls:sys_enter");
2374 (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2375 perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2376 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2380 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2381 "raw_syscalls:sys_exit");
2383 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2384 "syscalls:sys_exit");
2386 (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2387 perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2388 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2392 evlist__for_each(session->evlist, evsel) {
2393 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2394 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2395 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2396 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2397 evsel->handler = trace__pgfault;
2400 err = parse_target_str(trace);
2406 err = perf_session__process_events(session, &trace->tool);
2408 pr_err("Failed to process events, error %d", err);
2410 else if (trace->summary)
2411 trace__fprintf_thread_summary(trace, trace->output);
2414 perf_session__delete(session);
2419 static size_t trace__fprintf_threads_header(FILE *fp)
2423 printed = fprintf(fp, "\n Summary of events:\n\n");
2428 static size_t thread__dump_stats(struct thread_trace *ttrace,
2429 struct trace *trace, FILE *fp)
2431 struct stats *stats;
2434 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2439 printed += fprintf(fp, "\n");
2441 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2442 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2443 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
2445 /* each int_node is a syscall */
2447 stats = inode->priv;
2449 double min = (double)(stats->min) / NSEC_PER_MSEC;
2450 double max = (double)(stats->max) / NSEC_PER_MSEC;
2451 double avg = avg_stats(stats);
2453 u64 n = (u64) stats->n;
2455 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2456 avg /= NSEC_PER_MSEC;
2458 sc = &trace->syscalls.table[inode->i];
2459 printed += fprintf(fp, " %-15s", sc->name);
2460 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
2462 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2465 inode = intlist__next(inode);
2468 printed += fprintf(fp, "\n\n");
2473 /* struct used to pass data to per-thread function */
2474 struct summary_data {
2476 struct trace *trace;
2480 static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2482 struct summary_data *data = priv;
2483 FILE *fp = data->fp;
2484 size_t printed = data->printed;
2485 struct trace *trace = data->trace;
2486 struct thread_trace *ttrace = thread__priv(thread);
2492 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2494 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2495 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2496 printed += fprintf(fp, "%.1f%%", ratio);
2498 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2500 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2501 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2502 printed += thread__dump_stats(ttrace, trace, fp);
2504 data->printed += printed;
2509 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2511 struct summary_data data = {
2515 data.printed = trace__fprintf_threads_header(fp);
2517 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2519 return data.printed;
2522 static int trace__set_duration(const struct option *opt, const char *str,
2523 int unset __maybe_unused)
2525 struct trace *trace = opt->value;
2527 trace->duration_filter = atof(str);
2531 static int trace__set_filter_pids(const struct option *opt, const char *str,
2532 int unset __maybe_unused)
2536 struct trace *trace = opt->value;
2538 * FIXME: introduce a intarray class, plain parse csv and create a
2539 * { int nr, int entries[] } struct...
2541 struct intlist *list = intlist__new(str);
2546 i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2547 trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2549 if (trace->filter_pids.entries == NULL)
2552 trace->filter_pids.entries[0] = getpid();
2554 for (i = 1; i < trace->filter_pids.nr; ++i)
2555 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2557 intlist__delete(list);
2563 static int trace__open_output(struct trace *trace, const char *filename)
2567 if (!stat(filename, &st) && st.st_size) {
2568 char oldname[PATH_MAX];
2570 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2572 rename(filename, oldname);
2575 trace->output = fopen(filename, "w");
2577 return trace->output == NULL ? -errno : 0;
2580 static int parse_pagefaults(const struct option *opt, const char *str,
2581 int unset __maybe_unused)
2583 int *trace_pgfaults = opt->value;
2585 if (strcmp(str, "all") == 0)
2586 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2587 else if (strcmp(str, "maj") == 0)
2588 *trace_pgfaults |= TRACE_PFMAJ;
2589 else if (strcmp(str, "min") == 0)
2590 *trace_pgfaults |= TRACE_PFMIN;
2597 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2599 struct perf_evsel *evsel;
2601 evlist__for_each(evlist, evsel)
2602 evsel->handler = handler;
2605 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2607 const char * const trace_usage[] = {
2608 "perf trace [<options>] [<command>]",
2609 "perf trace [<options>] -- <command> [<options>]",
2610 "perf trace record [<options>] [<command>]",
2611 "perf trace record [<options>] -- <command> [<options>]",
2614 struct trace trace = {
2616 .machine = audit_detect_machine(),
2617 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2627 .user_freq = UINT_MAX,
2628 .user_interval = ULLONG_MAX,
2629 .no_buffering = true,
2630 .mmap_pages = UINT_MAX,
2634 .trace_syscalls = true,
2636 const char *output_name = NULL;
2637 const char *ev_qualifier_str = NULL;
2638 const struct option trace_options[] = {
2639 OPT_CALLBACK(0, "event", &trace.evlist, "event",
2640 "event selector. use 'perf list' to list available events",
2641 parse_events_option),
2642 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2643 "show the thread COMM next to its id"),
2644 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2645 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2646 "list of events to trace"),
2647 OPT_STRING('o', "output", &output_name, "file", "output file name"),
2648 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
2649 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2650 "trace events on existing process id"),
2651 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
2652 "trace events on existing thread id"),
2653 OPT_CALLBACK(0, "filter-pids", &trace, "float",
2654 "show only events with duration > N.M ms", trace__set_filter_pids),
2655 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
2656 "system-wide collection from all CPUs"),
2657 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
2658 "list of cpus to monitor"),
2659 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
2660 "child tasks do not inherit counters"),
2661 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2662 "number of mmap data pages",
2663 perf_evlist__parse_mmap_pages),
2664 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
2666 OPT_CALLBACK(0, "duration", &trace, "float",
2667 "show only events with duration > N.M ms",
2668 trace__set_duration),
2669 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
2670 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
2671 OPT_BOOLEAN('T', "time", &trace.full_time,
2672 "Show full timestamp, not time relative to first start"),
2673 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2674 "Show only syscall summary with statistics"),
2675 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2676 "Show all syscalls and summary with statistics"),
2677 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2678 "Trace pagefaults", parse_pagefaults, "maj"),
2679 OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
2685 signal(SIGSEGV, sighandler_dump_stack);
2686 signal(SIGFPE, sighandler_dump_stack);
2688 trace.evlist = perf_evlist__new();
2689 if (trace.evlist == NULL)
2692 if (trace.evlist == NULL) {
2693 pr_err("Not enough memory to run!\n");
2697 argc = parse_options(argc, argv, trace_options, trace_usage,
2698 PARSE_OPT_STOP_AT_NON_OPTION);
2700 if (trace.trace_pgfaults) {
2701 trace.opts.sample_address = true;
2702 trace.opts.sample_time = true;
2705 if (trace.evlist->nr_entries > 0)
2706 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
2708 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2709 return trace__record(&trace, argc-1, &argv[1]);
2711 /* summary_only implies summary option, but don't overwrite summary if set */
2712 if (trace.summary_only)
2713 trace.summary = trace.summary_only;
2715 if (!trace.trace_syscalls && !trace.trace_pgfaults &&
2716 trace.evlist->nr_entries == 0 /* Was --events used? */) {
2717 pr_err("Please specify something to trace.\n");
2721 if (output_name != NULL) {
2722 err = trace__open_output(&trace, output_name);
2724 perror("failed to create output file");
2729 if (ev_qualifier_str != NULL) {
2730 const char *s = ev_qualifier_str;
2732 trace.not_ev_qualifier = *s == '!';
2733 if (trace.not_ev_qualifier)
2735 trace.ev_qualifier = strlist__new(true, s);
2736 if (trace.ev_qualifier == NULL) {
2737 fputs("Not enough memory to parse event qualifier",
2744 err = target__validate(&trace.opts.target);
2746 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2747 fprintf(trace.output, "%s", bf);
2751 err = target__parse_uid(&trace.opts.target);
2753 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2754 fprintf(trace.output, "%s", bf);
2758 if (!argc && target__none(&trace.opts.target))
2759 trace.opts.target.system_wide = true;
2762 err = trace__replay(&trace);
2764 err = trace__run(&trace, argc, argv);
2767 if (output_name != NULL)
2768 fclose(trace.output);