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) \
55 return *(u##bits *)(sample->raw_data + field->offset); \
63 #define TP_UINT_FIELD__SWAPPED(bits) \
64 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
66 u##bits value = *(u##bits *)(sample->raw_data + field->offset); \
67 return bswap_##bits(value);\
70 TP_UINT_FIELD__SWAPPED(16);
71 TP_UINT_FIELD__SWAPPED(32);
72 TP_UINT_FIELD__SWAPPED(64);
74 static int tp_field__init_uint(struct tp_field *field,
75 struct format_field *format_field,
78 field->offset = format_field->offset;
80 switch (format_field->size) {
82 field->integer = tp_field__u8;
85 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
88 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
91 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
100 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
102 return sample->raw_data + field->offset;
105 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
107 field->offset = format_field->offset;
108 field->pointer = tp_field__ptr;
115 struct tp_field args, ret;
119 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
120 struct tp_field *field,
123 struct format_field *format_field = perf_evsel__field(evsel, name);
125 if (format_field == NULL)
128 return tp_field__init_uint(field, format_field, evsel->needs_swap);
131 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
132 ({ struct syscall_tp *sc = evsel->priv;\
133 perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
135 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
136 struct tp_field *field,
139 struct format_field *format_field = perf_evsel__field(evsel, name);
141 if (format_field == NULL)
144 return tp_field__init_ptr(field, format_field);
147 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
148 ({ struct syscall_tp *sc = evsel->priv;\
149 perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
151 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
154 perf_evsel__delete(evsel);
157 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
159 evsel->priv = malloc(sizeof(struct syscall_tp));
160 if (evsel->priv != NULL) {
161 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
164 evsel->handler = handler;
175 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
177 struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
179 /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
181 evsel = perf_evsel__newtp("syscalls", direction);
184 if (perf_evsel__init_syscall_tp(evsel, handler))
191 perf_evsel__delete_priv(evsel);
195 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
196 ({ struct syscall_tp *fields = evsel->priv; \
197 fields->name.integer(&fields->name, sample); })
199 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
200 ({ struct syscall_tp *fields = evsel->priv; \
201 fields->name.pointer(&fields->name, sample); })
203 static int perf_evlist__add_syscall_newtp(struct perf_evlist *evlist,
204 void *sys_enter_handler,
205 void *sys_exit_handler)
208 struct perf_evsel *sys_enter, *sys_exit;
210 sys_enter = perf_evsel__syscall_newtp("sys_enter", sys_enter_handler);
211 if (sys_enter == NULL)
214 if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
215 goto out_delete_sys_enter;
217 sys_exit = perf_evsel__syscall_newtp("sys_exit", sys_exit_handler);
218 if (sys_exit == NULL)
219 goto out_delete_sys_enter;
221 if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
222 goto out_delete_sys_exit;
224 perf_evlist__add(evlist, sys_enter);
225 perf_evlist__add(evlist, sys_exit);
232 perf_evsel__delete_priv(sys_exit);
233 out_delete_sys_enter:
234 perf_evsel__delete_priv(sys_enter);
241 struct thread *thread;
251 const char **entries;
254 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
255 .nr_entries = ARRAY_SIZE(array), \
259 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
261 .nr_entries = ARRAY_SIZE(array), \
265 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
267 struct syscall_arg *arg)
269 struct strarray *sa = arg->parm;
270 int idx = arg->val - sa->offset;
272 if (idx < 0 || idx >= sa->nr_entries)
273 return scnprintf(bf, size, intfmt, arg->val);
275 return scnprintf(bf, size, "%s", sa->entries[idx]);
278 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
279 struct syscall_arg *arg)
281 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
284 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
286 #if defined(__i386__) || defined(__x86_64__)
288 * FIXME: Make this available to all arches as soon as the ioctl beautifier
289 * gets rewritten to support all arches.
291 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
292 struct syscall_arg *arg)
294 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
297 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
298 #endif /* defined(__i386__) || defined(__x86_64__) */
300 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
301 struct syscall_arg *arg);
303 #define SCA_FD syscall_arg__scnprintf_fd
305 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
306 struct syscall_arg *arg)
311 return scnprintf(bf, size, "CWD");
313 return syscall_arg__scnprintf_fd(bf, size, arg);
316 #define SCA_FDAT syscall_arg__scnprintf_fd_at
318 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
319 struct syscall_arg *arg);
321 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
323 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
324 struct syscall_arg *arg)
326 return scnprintf(bf, size, "%#lx", arg->val);
329 #define SCA_HEX syscall_arg__scnprintf_hex
331 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
332 struct syscall_arg *arg)
334 int printed = 0, prot = arg->val;
336 if (prot == PROT_NONE)
337 return scnprintf(bf, size, "NONE");
338 #define P_MMAP_PROT(n) \
339 if (prot & PROT_##n) { \
340 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
350 P_MMAP_PROT(GROWSDOWN);
351 P_MMAP_PROT(GROWSUP);
355 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
360 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
362 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
363 struct syscall_arg *arg)
365 int printed = 0, flags = arg->val;
367 #define P_MMAP_FLAG(n) \
368 if (flags & MAP_##n) { \
369 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
374 P_MMAP_FLAG(PRIVATE);
378 P_MMAP_FLAG(ANONYMOUS);
379 P_MMAP_FLAG(DENYWRITE);
380 P_MMAP_FLAG(EXECUTABLE);
383 P_MMAP_FLAG(GROWSDOWN);
385 P_MMAP_FLAG(HUGETLB);
388 P_MMAP_FLAG(NONBLOCK);
389 P_MMAP_FLAG(NORESERVE);
390 P_MMAP_FLAG(POPULATE);
392 #ifdef MAP_UNINITIALIZED
393 P_MMAP_FLAG(UNINITIALIZED);
398 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
403 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
405 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
406 struct syscall_arg *arg)
408 int behavior = arg->val;
411 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
414 P_MADV_BHV(SEQUENTIAL);
415 P_MADV_BHV(WILLNEED);
416 P_MADV_BHV(DONTNEED);
418 P_MADV_BHV(DONTFORK);
420 P_MADV_BHV(HWPOISON);
421 #ifdef MADV_SOFT_OFFLINE
422 P_MADV_BHV(SOFT_OFFLINE);
424 P_MADV_BHV(MERGEABLE);
425 P_MADV_BHV(UNMERGEABLE);
427 P_MADV_BHV(HUGEPAGE);
429 #ifdef MADV_NOHUGEPAGE
430 P_MADV_BHV(NOHUGEPAGE);
433 P_MADV_BHV(DONTDUMP);
442 return scnprintf(bf, size, "%#x", behavior);
445 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
447 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
448 struct syscall_arg *arg)
450 int printed = 0, op = arg->val;
453 return scnprintf(bf, size, "NONE");
455 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
456 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
471 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
476 #define SCA_FLOCK syscall_arg__scnprintf_flock
478 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
480 enum syscall_futex_args {
481 SCF_UADDR = (1 << 0),
484 SCF_TIMEOUT = (1 << 3),
485 SCF_UADDR2 = (1 << 4),
489 int cmd = op & FUTEX_CMD_MASK;
493 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
494 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
495 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
496 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
497 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
498 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
499 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
500 P_FUTEX_OP(WAKE_OP); break;
501 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
502 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
503 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
504 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
505 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
506 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
507 default: printed = scnprintf(bf, size, "%#x", cmd); break;
510 if (op & FUTEX_PRIVATE_FLAG)
511 printed += scnprintf(bf + printed, size - printed, "|PRIV");
513 if (op & FUTEX_CLOCK_REALTIME)
514 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
519 #define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
521 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
522 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
524 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
525 static DEFINE_STRARRAY(itimers);
527 static const char *whences[] = { "SET", "CUR", "END",
535 static DEFINE_STRARRAY(whences);
537 static const char *fcntl_cmds[] = {
538 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
539 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
540 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
543 static DEFINE_STRARRAY(fcntl_cmds);
545 static const char *rlimit_resources[] = {
546 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
547 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
550 static DEFINE_STRARRAY(rlimit_resources);
552 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
553 static DEFINE_STRARRAY(sighow);
555 static const char *clockid[] = {
556 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
557 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
559 static DEFINE_STRARRAY(clockid);
561 static const char *socket_families[] = {
562 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
563 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
564 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
565 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
566 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
567 "ALG", "NFC", "VSOCK",
569 static DEFINE_STRARRAY(socket_families);
571 #ifndef SOCK_TYPE_MASK
572 #define SOCK_TYPE_MASK 0xf
575 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
576 struct syscall_arg *arg)
580 flags = type & ~SOCK_TYPE_MASK;
582 type &= SOCK_TYPE_MASK;
584 * Can't use a strarray, MIPS may override for ABI reasons.
587 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
592 P_SK_TYPE(SEQPACKET);
597 printed = scnprintf(bf, size, "%#x", type);
600 #define P_SK_FLAG(n) \
601 if (flags & SOCK_##n) { \
602 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
603 flags &= ~SOCK_##n; \
611 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
616 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
619 #define MSG_PROBE 0x10
621 #ifndef MSG_WAITFORONE
622 #define MSG_WAITFORONE 0x10000
624 #ifndef MSG_SENDPAGE_NOTLAST
625 #define MSG_SENDPAGE_NOTLAST 0x20000
628 #define MSG_FASTOPEN 0x20000000
631 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
632 struct syscall_arg *arg)
634 int printed = 0, flags = arg->val;
637 return scnprintf(bf, size, "NONE");
638 #define P_MSG_FLAG(n) \
639 if (flags & MSG_##n) { \
640 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
646 P_MSG_FLAG(DONTROUTE);
651 P_MSG_FLAG(DONTWAIT);
658 P_MSG_FLAG(ERRQUEUE);
659 P_MSG_FLAG(NOSIGNAL);
661 P_MSG_FLAG(WAITFORONE);
662 P_MSG_FLAG(SENDPAGE_NOTLAST);
663 P_MSG_FLAG(FASTOPEN);
664 P_MSG_FLAG(CMSG_CLOEXEC);
668 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
673 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
675 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
676 struct syscall_arg *arg)
681 if (mode == F_OK) /* 0 */
682 return scnprintf(bf, size, "F");
684 if (mode & n##_OK) { \
685 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
695 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
700 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
702 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
703 struct syscall_arg *arg)
705 int printed = 0, flags = arg->val;
707 if (!(flags & O_CREAT))
708 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
711 return scnprintf(bf, size, "RDONLY");
713 if (flags & O_##n) { \
714 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
738 if ((flags & O_SYNC) == O_SYNC)
739 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
751 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
756 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
758 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
759 struct syscall_arg *arg)
761 int printed = 0, flags = arg->val;
764 return scnprintf(bf, size, "NONE");
766 if (flags & EFD_##n) { \
767 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
777 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
782 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
784 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
785 struct syscall_arg *arg)
787 int printed = 0, flags = arg->val;
790 if (flags & O_##n) { \
791 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
800 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
805 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
807 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
812 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
855 return scnprintf(bf, size, "%#x", sig);
858 #define SCA_SIGNUM syscall_arg__scnprintf_signum
860 #if defined(__i386__) || defined(__x86_64__)
862 * FIXME: Make this available to all arches.
864 #define TCGETS 0x5401
866 static const char *tioctls[] = {
867 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
868 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
869 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
870 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
871 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
872 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
873 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
874 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
875 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
876 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
877 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
878 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
879 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
880 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
881 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
884 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
885 #endif /* defined(__i386__) || defined(__x86_64__) */
887 #define STRARRAY(arg, name, array) \
888 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
889 .arg_parm = { [arg] = &strarray__##array, }
891 static struct syscall_fmt {
894 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
900 { .name = "access", .errmsg = true,
901 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
902 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
903 { .name = "brk", .hexret = true,
904 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
905 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
906 { .name = "close", .errmsg = true,
907 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
908 { .name = "connect", .errmsg = true, },
909 { .name = "dup", .errmsg = true,
910 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
911 { .name = "dup2", .errmsg = true,
912 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
913 { .name = "dup3", .errmsg = true,
914 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
915 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
916 { .name = "eventfd2", .errmsg = true,
917 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
918 { .name = "faccessat", .errmsg = true,
919 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
920 { .name = "fadvise64", .errmsg = true,
921 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
922 { .name = "fallocate", .errmsg = true,
923 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
924 { .name = "fchdir", .errmsg = true,
925 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
926 { .name = "fchmod", .errmsg = true,
927 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
928 { .name = "fchmodat", .errmsg = true,
929 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
930 { .name = "fchown", .errmsg = true,
931 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
932 { .name = "fchownat", .errmsg = true,
933 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
934 { .name = "fcntl", .errmsg = true,
935 .arg_scnprintf = { [0] = SCA_FD, /* fd */
936 [1] = SCA_STRARRAY, /* cmd */ },
937 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
938 { .name = "fdatasync", .errmsg = true,
939 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
940 { .name = "flock", .errmsg = true,
941 .arg_scnprintf = { [0] = SCA_FD, /* fd */
942 [1] = SCA_FLOCK, /* cmd */ }, },
943 { .name = "fsetxattr", .errmsg = true,
944 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
945 { .name = "fstat", .errmsg = true, .alias = "newfstat",
946 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
947 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
948 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
949 { .name = "fstatfs", .errmsg = true,
950 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
951 { .name = "fsync", .errmsg = true,
952 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
953 { .name = "ftruncate", .errmsg = true,
954 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
955 { .name = "futex", .errmsg = true,
956 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
957 { .name = "futimesat", .errmsg = true,
958 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
959 { .name = "getdents", .errmsg = true,
960 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
961 { .name = "getdents64", .errmsg = true,
962 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
963 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
964 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
965 { .name = "ioctl", .errmsg = true,
966 .arg_scnprintf = { [0] = SCA_FD, /* fd */
967 #if defined(__i386__) || defined(__x86_64__)
969 * FIXME: Make this available to all arches.
971 [1] = SCA_STRHEXARRAY, /* cmd */
972 [2] = SCA_HEX, /* arg */ },
973 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
975 [2] = SCA_HEX, /* arg */ }, },
977 { .name = "kill", .errmsg = true,
978 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
979 { .name = "linkat", .errmsg = true,
980 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
981 { .name = "lseek", .errmsg = true,
982 .arg_scnprintf = { [0] = SCA_FD, /* fd */
983 [2] = SCA_STRARRAY, /* whence */ },
984 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
985 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
986 { .name = "madvise", .errmsg = true,
987 .arg_scnprintf = { [0] = SCA_HEX, /* start */
988 [2] = SCA_MADV_BHV, /* behavior */ }, },
989 { .name = "mkdirat", .errmsg = true,
990 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
991 { .name = "mknodat", .errmsg = true,
992 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
993 { .name = "mlock", .errmsg = true,
994 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
995 { .name = "mlockall", .errmsg = true,
996 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
997 { .name = "mmap", .hexret = true,
998 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
999 [2] = SCA_MMAP_PROT, /* prot */
1000 [3] = SCA_MMAP_FLAGS, /* flags */
1001 [4] = SCA_FD, /* fd */ }, },
1002 { .name = "mprotect", .errmsg = true,
1003 .arg_scnprintf = { [0] = SCA_HEX, /* start */
1004 [2] = SCA_MMAP_PROT, /* prot */ }, },
1005 { .name = "mremap", .hexret = true,
1006 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1007 [4] = SCA_HEX, /* new_addr */ }, },
1008 { .name = "munlock", .errmsg = true,
1009 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1010 { .name = "munmap", .errmsg = true,
1011 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1012 { .name = "name_to_handle_at", .errmsg = true,
1013 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1014 { .name = "newfstatat", .errmsg = true,
1015 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1016 { .name = "open", .errmsg = true,
1017 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1018 { .name = "open_by_handle_at", .errmsg = true,
1019 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1020 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1021 { .name = "openat", .errmsg = true,
1022 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1023 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1024 { .name = "pipe2", .errmsg = true,
1025 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1026 { .name = "poll", .errmsg = true, .timeout = true, },
1027 { .name = "ppoll", .errmsg = true, .timeout = true, },
1028 { .name = "pread", .errmsg = true, .alias = "pread64",
1029 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1030 { .name = "preadv", .errmsg = true, .alias = "pread",
1031 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1032 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1033 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
1034 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1035 { .name = "pwritev", .errmsg = true,
1036 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1037 { .name = "read", .errmsg = true,
1038 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1039 { .name = "readlinkat", .errmsg = true,
1040 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1041 { .name = "readv", .errmsg = true,
1042 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1043 { .name = "recvfrom", .errmsg = true,
1044 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1045 { .name = "recvmmsg", .errmsg = true,
1046 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1047 { .name = "recvmsg", .errmsg = true,
1048 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1049 { .name = "renameat", .errmsg = true,
1050 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1051 { .name = "rt_sigaction", .errmsg = true,
1052 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1053 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
1054 { .name = "rt_sigqueueinfo", .errmsg = true,
1055 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1056 { .name = "rt_tgsigqueueinfo", .errmsg = true,
1057 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1058 { .name = "select", .errmsg = true, .timeout = true, },
1059 { .name = "sendmmsg", .errmsg = true,
1060 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1061 { .name = "sendmsg", .errmsg = true,
1062 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
1063 { .name = "sendto", .errmsg = true,
1064 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
1065 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
1066 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1067 { .name = "shutdown", .errmsg = true,
1068 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1069 { .name = "socket", .errmsg = true,
1070 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1071 [1] = SCA_SK_TYPE, /* type */ },
1072 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1073 { .name = "socketpair", .errmsg = true,
1074 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1075 [1] = SCA_SK_TYPE, /* type */ },
1076 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
1077 { .name = "stat", .errmsg = true, .alias = "newstat", },
1078 { .name = "symlinkat", .errmsg = true,
1079 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1080 { .name = "tgkill", .errmsg = true,
1081 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1082 { .name = "tkill", .errmsg = true,
1083 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1084 { .name = "uname", .errmsg = true, .alias = "newuname", },
1085 { .name = "unlinkat", .errmsg = true,
1086 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1087 { .name = "utimensat", .errmsg = true,
1088 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
1089 { .name = "write", .errmsg = true,
1090 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1091 { .name = "writev", .errmsg = true,
1092 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1095 static int syscall_fmt__cmp(const void *name, const void *fmtp)
1097 const struct syscall_fmt *fmt = fmtp;
1098 return strcmp(name, fmt->name);
1101 static struct syscall_fmt *syscall_fmt__find(const char *name)
1103 const int nmemb = ARRAY_SIZE(syscall_fmts);
1104 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1108 struct event_format *tp_format;
1112 struct syscall_fmt *fmt;
1113 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1117 static size_t fprintf_duration(unsigned long t, FILE *fp)
1119 double duration = (double)t / NSEC_PER_MSEC;
1120 size_t printed = fprintf(fp, "(");
1122 if (duration >= 1.0)
1123 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1124 else if (duration >= 0.01)
1125 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1127 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1128 return printed + fprintf(fp, "): ");
1131 struct thread_trace {
1135 unsigned long nr_events;
1143 struct intlist *syscall_stats;
1146 static struct thread_trace *thread_trace__new(void)
1148 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
1151 ttrace->paths.max = -1;
1153 ttrace->syscall_stats = intlist__new(NULL);
1158 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1160 struct thread_trace *ttrace;
1165 if (thread->priv == NULL)
1166 thread->priv = thread_trace__new();
1168 if (thread->priv == NULL)
1171 ttrace = thread->priv;
1172 ++ttrace->nr_events;
1176 color_fprintf(fp, PERF_COLOR_RED,
1177 "WARNING: not enough memory, dropping samples!\n");
1181 #define TRACE_PFMAJ (1 << 0)
1182 #define TRACE_PFMIN (1 << 1)
1185 struct perf_tool tool;
1192 struct syscall *table;
1194 struct record_opts opts;
1195 struct machine *host;
1198 unsigned long nr_events;
1199 struct strlist *ev_qualifier;
1200 const char *last_vfs_getname;
1201 struct intlist *tid_list;
1202 struct intlist *pid_list;
1203 double duration_filter;
1209 bool not_ev_qualifier;
1213 bool multiple_threads;
1217 bool show_tool_stats;
1221 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1223 struct thread_trace *ttrace = thread->priv;
1225 if (fd > ttrace->paths.max) {
1226 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1231 if (ttrace->paths.max != -1) {
1232 memset(npath + ttrace->paths.max + 1, 0,
1233 (fd - ttrace->paths.max) * sizeof(char *));
1235 memset(npath, 0, (fd + 1) * sizeof(char *));
1238 ttrace->paths.table = npath;
1239 ttrace->paths.max = fd;
1242 ttrace->paths.table[fd] = strdup(pathname);
1244 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1247 static int thread__read_fd_path(struct thread *thread, int fd)
1249 char linkname[PATH_MAX], pathname[PATH_MAX];
1253 if (thread->pid_ == thread->tid) {
1254 scnprintf(linkname, sizeof(linkname),
1255 "/proc/%d/fd/%d", thread->pid_, fd);
1257 scnprintf(linkname, sizeof(linkname),
1258 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1261 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1264 ret = readlink(linkname, pathname, sizeof(pathname));
1266 if (ret < 0 || ret > st.st_size)
1269 pathname[ret] = '\0';
1270 return trace__set_fd_pathname(thread, fd, pathname);
1273 static const char *thread__fd_path(struct thread *thread, int fd,
1274 struct trace *trace)
1276 struct thread_trace *ttrace = thread->priv;
1284 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1287 ++trace->stats.proc_getname;
1288 if (thread__read_fd_path(thread, fd))
1292 return ttrace->paths.table[fd];
1295 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1296 struct syscall_arg *arg)
1299 size_t printed = scnprintf(bf, size, "%d", fd);
1300 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1303 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1308 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1309 struct syscall_arg *arg)
1312 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1313 struct thread_trace *ttrace = arg->thread->priv;
1315 if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1316 zfree(&ttrace->paths.table[fd]);
1321 static bool trace__filter_duration(struct trace *trace, double t)
1323 return t < (trace->duration_filter * NSEC_PER_MSEC);
1326 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1328 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1330 return fprintf(fp, "%10.3f ", ts);
1333 static bool done = false;
1334 static bool interrupted = false;
1336 static void sig_handler(int sig)
1339 interrupted = sig == SIGINT;
1342 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1343 u64 duration, u64 tstamp, FILE *fp)
1345 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1346 printed += fprintf_duration(duration, fp);
1348 if (trace->multiple_threads) {
1349 if (trace->show_comm)
1350 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1351 printed += fprintf(fp, "%d ", thread->tid);
1357 static int trace__process_event(struct trace *trace, struct machine *machine,
1358 union perf_event *event, struct perf_sample *sample)
1362 switch (event->header.type) {
1363 case PERF_RECORD_LOST:
1364 color_fprintf(trace->output, PERF_COLOR_RED,
1365 "LOST %" PRIu64 " events!\n", event->lost.lost);
1366 ret = machine__process_lost_event(machine, event, sample);
1368 ret = machine__process_event(machine, event, sample);
1375 static int trace__tool_process(struct perf_tool *tool,
1376 union perf_event *event,
1377 struct perf_sample *sample,
1378 struct machine *machine)
1380 struct trace *trace = container_of(tool, struct trace, tool);
1381 return trace__process_event(trace, machine, event, sample);
1384 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1386 int err = symbol__init();
1391 trace->host = machine__new_host();
1392 if (trace->host == NULL)
1395 err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1396 evlist->threads, trace__tool_process, false);
1403 static int syscall__set_arg_fmts(struct syscall *sc)
1405 struct format_field *field;
1408 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
1409 if (sc->arg_scnprintf == NULL)
1413 sc->arg_parm = sc->fmt->arg_parm;
1415 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
1416 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1417 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1418 else if (field->flags & FIELD_IS_POINTER)
1419 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1426 static int trace__read_syscall_info(struct trace *trace, int id)
1430 const char *name = audit_syscall_to_name(id, trace->audit.machine);
1435 if (id > trace->syscalls.max) {
1436 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1438 if (nsyscalls == NULL)
1441 if (trace->syscalls.max != -1) {
1442 memset(nsyscalls + trace->syscalls.max + 1, 0,
1443 (id - trace->syscalls.max) * sizeof(*sc));
1445 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1448 trace->syscalls.table = nsyscalls;
1449 trace->syscalls.max = id;
1452 sc = trace->syscalls.table + id;
1455 if (trace->ev_qualifier) {
1456 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1458 if (!(in ^ trace->not_ev_qualifier)) {
1459 sc->filtered = true;
1461 * No need to do read tracepoint information since this will be
1468 sc->fmt = syscall_fmt__find(sc->name);
1470 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1471 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1473 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1474 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1475 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1478 if (sc->tp_format == NULL)
1481 sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1483 return syscall__set_arg_fmts(sc);
1486 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1487 unsigned long *args, struct trace *trace,
1488 struct thread *thread)
1492 if (sc->tp_format != NULL) {
1493 struct format_field *field;
1495 struct syscall_arg arg = {
1502 for (field = sc->tp_format->format.fields->next; field;
1503 field = field->next, ++arg.idx, bit <<= 1) {
1507 * Suppress this argument if its value is zero and
1508 * and we don't have a string associated in an
1511 if (args[arg.idx] == 0 &&
1512 !(sc->arg_scnprintf &&
1513 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1514 sc->arg_parm[arg.idx]))
1517 printed += scnprintf(bf + printed, size - printed,
1518 "%s%s: ", printed ? ", " : "", field->name);
1519 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1520 arg.val = args[arg.idx];
1522 arg.parm = sc->arg_parm[arg.idx];
1523 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1524 size - printed, &arg);
1526 printed += scnprintf(bf + printed, size - printed,
1527 "%ld", args[arg.idx]);
1534 printed += scnprintf(bf + printed, size - printed,
1536 printed ? ", " : "", i, args[i]);
1544 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1545 union perf_event *event,
1546 struct perf_sample *sample);
1548 static struct syscall *trace__syscall_info(struct trace *trace,
1549 struct perf_evsel *evsel, int id)
1555 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1556 * before that, leaving at a higher verbosity level till that is
1557 * explained. Reproduced with plain ftrace with:
1559 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1560 * grep "NR -1 " /t/trace_pipe
1562 * After generating some load on the machine.
1566 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1567 id, perf_evsel__name(evsel), ++n);
1572 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1573 trace__read_syscall_info(trace, id))
1576 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1579 return &trace->syscalls.table[id];
1583 fprintf(trace->output, "Problems reading syscall %d", id);
1584 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1585 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1586 fputs(" information\n", trace->output);
1591 static void thread__update_stats(struct thread_trace *ttrace,
1592 int id, struct perf_sample *sample)
1594 struct int_node *inode;
1595 struct stats *stats;
1598 inode = intlist__findnew(ttrace->syscall_stats, id);
1602 stats = inode->priv;
1603 if (stats == NULL) {
1604 stats = malloc(sizeof(struct stats));
1608 inode->priv = stats;
1611 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1612 duration = sample->time - ttrace->entry_time;
1614 update_stats(stats, duration);
1617 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1618 union perf_event *event __maybe_unused,
1619 struct perf_sample *sample)
1624 struct thread *thread;
1625 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1626 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1627 struct thread_trace *ttrace;
1635 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1636 ttrace = thread__trace(thread, trace->output);
1640 args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1642 if (ttrace->entry_str == NULL) {
1643 ttrace->entry_str = malloc(1024);
1644 if (!ttrace->entry_str)
1648 ttrace->entry_time = sample->time;
1649 msg = ttrace->entry_str;
1650 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1652 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1653 args, trace, thread);
1656 if (!trace->duration_filter && !trace->summary_only) {
1657 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1658 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1661 ttrace->entry_pending = true;
1666 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1667 union perf_event *event __maybe_unused,
1668 struct perf_sample *sample)
1672 struct thread *thread;
1673 int id = perf_evsel__sc_tp_uint(evsel, id, sample);
1674 struct syscall *sc = trace__syscall_info(trace, evsel, id);
1675 struct thread_trace *ttrace;
1683 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1684 ttrace = thread__trace(thread, trace->output);
1689 thread__update_stats(ttrace, id, sample);
1691 ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
1693 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1694 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1695 trace->last_vfs_getname = NULL;
1696 ++trace->stats.vfs_getname;
1699 ttrace->exit_time = sample->time;
1701 if (ttrace->entry_time) {
1702 duration = sample->time - ttrace->entry_time;
1703 if (trace__filter_duration(trace, duration))
1705 } else if (trace->duration_filter)
1708 if (trace->summary_only)
1711 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
1713 if (ttrace->entry_pending) {
1714 fprintf(trace->output, "%-70s", ttrace->entry_str);
1716 fprintf(trace->output, " ... [");
1717 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1718 fprintf(trace->output, "]: %s()", sc->name);
1721 if (sc->fmt == NULL) {
1723 fprintf(trace->output, ") = %d", ret);
1724 } else if (ret < 0 && sc->fmt->errmsg) {
1726 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1727 *e = audit_errno_to_name(-ret);
1729 fprintf(trace->output, ") = -1 %s %s", e, emsg);
1730 } else if (ret == 0 && sc->fmt->timeout)
1731 fprintf(trace->output, ") = 0 Timeout");
1732 else if (sc->fmt->hexret)
1733 fprintf(trace->output, ") = %#x", ret);
1737 fputc('\n', trace->output);
1739 ttrace->entry_pending = false;
1744 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1745 union perf_event *event __maybe_unused,
1746 struct perf_sample *sample)
1748 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1752 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1753 union perf_event *event __maybe_unused,
1754 struct perf_sample *sample)
1756 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1757 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
1758 struct thread *thread = machine__findnew_thread(trace->host,
1761 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1766 ttrace->runtime_ms += runtime_ms;
1767 trace->runtime_ms += runtime_ms;
1771 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1773 perf_evsel__strval(evsel, sample, "comm"),
1774 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1776 perf_evsel__intval(evsel, sample, "vruntime"));
1780 static void print_location(FILE *f, struct perf_sample *sample,
1781 struct addr_location *al,
1782 bool print_dso, bool print_sym)
1785 if ((verbose || print_dso) && al->map)
1786 fprintf(f, "%s@", al->map->dso->long_name);
1788 if ((verbose || print_sym) && al->sym)
1789 fprintf(f, "%s+0x%lx", al->sym->name,
1790 al->addr - al->sym->start);
1792 fprintf(f, "0x%lx", al->addr);
1794 fprintf(f, "0x%lx", sample->addr);
1797 static int trace__pgfault(struct trace *trace,
1798 struct perf_evsel *evsel,
1799 union perf_event *event,
1800 struct perf_sample *sample)
1802 struct thread *thread;
1803 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1804 struct addr_location al;
1805 char map_type = 'd';
1807 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1809 thread__find_addr_location(thread, trace->host, cpumode, MAP__FUNCTION,
1812 trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
1814 fprintf(trace->output, "%sfault [",
1815 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
1818 print_location(trace->output, sample, &al, false, true);
1820 fprintf(trace->output, "] => ");
1822 thread__find_addr_location(thread, trace->host, cpumode, MAP__VARIABLE,
1826 thread__find_addr_location(thread, trace->host, cpumode,
1827 MAP__FUNCTION, sample->addr, &al);
1835 print_location(trace->output, sample, &al, true, false);
1837 fprintf(trace->output, " (%c%c)\n", map_type, al.level);
1842 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1844 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1845 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1848 if (trace->pid_list || trace->tid_list)
1854 static int trace__process_sample(struct perf_tool *tool,
1855 union perf_event *event,
1856 struct perf_sample *sample,
1857 struct perf_evsel *evsel,
1858 struct machine *machine __maybe_unused)
1860 struct trace *trace = container_of(tool, struct trace, tool);
1863 tracepoint_handler handler = evsel->handler;
1865 if (skip_sample(trace, sample))
1868 if (!trace->full_time && trace->base_time == 0)
1869 trace->base_time = sample->time;
1873 handler(trace, evsel, event, sample);
1879 static int parse_target_str(struct trace *trace)
1881 if (trace->opts.target.pid) {
1882 trace->pid_list = intlist__new(trace->opts.target.pid);
1883 if (trace->pid_list == NULL) {
1884 pr_err("Error parsing process id string\n");
1889 if (trace->opts.target.tid) {
1890 trace->tid_list = intlist__new(trace->opts.target.tid);
1891 if (trace->tid_list == NULL) {
1892 pr_err("Error parsing thread id string\n");
1900 static int trace__record(struct trace *trace, int argc, const char **argv)
1902 unsigned int rec_argc, i, j;
1903 const char **rec_argv;
1904 const char * const record_args[] = {
1911 const char * const sc_args[] = { "-e", };
1912 unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
1913 const char * const majpf_args[] = { "-e", "major-faults" };
1914 unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
1915 const char * const minpf_args[] = { "-e", "minor-faults" };
1916 unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
1918 /* +1 is for the event string below */
1919 rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
1920 majpf_args_nr + minpf_args_nr + argc;
1921 rec_argv = calloc(rec_argc + 1, sizeof(char *));
1923 if (rec_argv == NULL)
1927 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1928 rec_argv[j++] = record_args[i];
1930 for (i = 0; i < sc_args_nr; i++)
1931 rec_argv[j++] = sc_args[i];
1933 /* event string may be different for older kernels - e.g., RHEL6 */
1934 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
1935 rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
1936 else if (is_valid_tracepoint("syscalls:sys_enter"))
1937 rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
1939 pr_err("Neither raw_syscalls nor syscalls events exist.\n");
1943 if (trace->trace_pgfaults & TRACE_PFMAJ)
1944 for (i = 0; i < majpf_args_nr; i++)
1945 rec_argv[j++] = majpf_args[i];
1947 if (trace->trace_pgfaults & TRACE_PFMIN)
1948 for (i = 0; i < minpf_args_nr; i++)
1949 rec_argv[j++] = minpf_args[i];
1951 for (i = 0; i < (unsigned int)argc; i++)
1952 rec_argv[j++] = argv[i];
1954 return cmd_record(j, rec_argv, NULL);
1957 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
1959 static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
1961 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
1965 if (perf_evsel__field(evsel, "pathname") == NULL) {
1966 perf_evsel__delete(evsel);
1970 evsel->handler = trace__vfs_getname;
1971 perf_evlist__add(evlist, evsel);
1974 static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
1977 struct perf_evsel *evsel;
1978 struct perf_event_attr attr = {
1979 .type = PERF_TYPE_SOFTWARE,
1984 attr.config = config;
1986 event_attr_init(&attr);
1988 evsel = perf_evsel__new(&attr);
1992 evsel->handler = trace__pgfault;
1993 perf_evlist__add(evlist, evsel);
1998 static int trace__run(struct trace *trace, int argc, const char **argv)
2000 struct perf_evlist *evlist = perf_evlist__new();
2001 struct perf_evsel *evsel;
2003 unsigned long before;
2004 const bool forks = argc > 0;
2008 if (evlist == NULL) {
2009 fprintf(trace->output, "Not enough memory to run!\n");
2013 if (perf_evlist__add_syscall_newtp(evlist, trace__sys_enter, trace__sys_exit))
2016 perf_evlist__add_vfs_getname(evlist);
2018 if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2019 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ))
2022 if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2023 perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2027 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2028 trace__sched_stat_runtime))
2031 err = perf_evlist__create_maps(evlist, &trace->opts.target);
2033 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2034 goto out_delete_evlist;
2037 err = trace__symbols_init(trace, evlist);
2039 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2040 goto out_delete_evlist;
2043 perf_evlist__config(evlist, &trace->opts);
2045 signal(SIGCHLD, sig_handler);
2046 signal(SIGINT, sig_handler);
2049 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2052 fprintf(trace->output, "Couldn't run the workload!\n");
2053 goto out_delete_evlist;
2057 err = perf_evlist__open(evlist);
2059 goto out_error_open;
2061 err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2063 fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
2064 goto out_delete_evlist;
2067 perf_evlist__enable(evlist);
2070 perf_evlist__start_workload(evlist);
2072 trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
2074 before = trace->nr_events;
2076 for (i = 0; i < evlist->nr_mmaps; i++) {
2077 union perf_event *event;
2079 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2080 const u32 type = event->header.type;
2081 tracepoint_handler handler;
2082 struct perf_sample sample;
2086 err = perf_evlist__parse_sample(evlist, event, &sample);
2088 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2092 if (!trace->full_time && trace->base_time == 0)
2093 trace->base_time = sample.time;
2095 if (type != PERF_RECORD_SAMPLE) {
2096 trace__process_event(trace, trace->host, event, &sample);
2100 evsel = perf_evlist__id2evsel(evlist, sample.id);
2101 if (evsel == NULL) {
2102 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
2106 if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2107 sample.raw_data == NULL) {
2108 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2109 perf_evsel__name(evsel), sample.tid,
2110 sample.cpu, sample.raw_size);
2114 handler = evsel->handler;
2115 handler(trace, evsel, event, &sample);
2117 perf_evlist__mmap_consume(evlist, i);
2124 if (trace->nr_events == before) {
2125 int timeout = done ? 100 : -1;
2127 if (poll(evlist->pollfd, evlist->nr_fds, timeout) > 0)
2134 perf_evlist__disable(evlist);
2138 trace__fprintf_thread_summary(trace, trace->output);
2140 if (trace->show_tool_stats) {
2141 fprintf(trace->output, "Stats:\n "
2142 " vfs_getname : %" PRIu64 "\n"
2143 " proc_getname: %" PRIu64 "\n",
2144 trace->stats.vfs_getname,
2145 trace->stats.proc_getname);
2150 perf_evlist__delete(evlist);
2152 trace->live = false;
2155 char errbuf[BUFSIZ];
2158 perf_evlist__strerror_tp(evlist, errno, errbuf, sizeof(errbuf));
2162 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2165 fprintf(trace->output, "%s\n", errbuf);
2166 goto out_delete_evlist;
2170 static int trace__replay(struct trace *trace)
2172 const struct perf_evsel_str_handler handlers[] = {
2173 { "probe:vfs_getname", trace__vfs_getname, },
2175 struct perf_data_file file = {
2177 .mode = PERF_DATA_MODE_READ,
2179 struct perf_session *session;
2180 struct perf_evsel *evsel;
2183 trace->tool.sample = trace__process_sample;
2184 trace->tool.mmap = perf_event__process_mmap;
2185 trace->tool.mmap2 = perf_event__process_mmap2;
2186 trace->tool.comm = perf_event__process_comm;
2187 trace->tool.exit = perf_event__process_exit;
2188 trace->tool.fork = perf_event__process_fork;
2189 trace->tool.attr = perf_event__process_attr;
2190 trace->tool.tracing_data = perf_event__process_tracing_data;
2191 trace->tool.build_id = perf_event__process_build_id;
2193 trace->tool.ordered_samples = true;
2194 trace->tool.ordering_requires_timestamps = true;
2196 /* add tid to output */
2197 trace->multiple_threads = true;
2199 if (symbol__init() < 0)
2202 session = perf_session__new(&file, false, &trace->tool);
2203 if (session == NULL)
2206 trace->host = &session->machines.host;
2208 err = perf_session__set_tracepoints_handlers(session, handlers);
2212 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2213 "raw_syscalls:sys_enter");
2214 /* older kernels have syscalls tp versus raw_syscalls */
2216 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2217 "syscalls:sys_enter");
2218 if (evsel == NULL) {
2219 pr_err("Data file does not have raw_syscalls:sys_enter event\n");
2223 if (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2224 perf_evsel__init_sc_tp_ptr_field(evsel, args)) {
2225 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2229 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2230 "raw_syscalls:sys_exit");
2232 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2233 "syscalls:sys_exit");
2234 if (evsel == NULL) {
2235 pr_err("Data file does not have raw_syscalls:sys_exit event\n");
2239 if (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2240 perf_evsel__init_sc_tp_uint_field(evsel, ret)) {
2241 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2245 evlist__for_each(session->evlist, evsel) {
2246 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2247 (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2248 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2249 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2250 evsel->handler = trace__pgfault;
2253 err = parse_target_str(trace);
2259 err = perf_session__process_events(session, &trace->tool);
2261 pr_err("Failed to process events, error %d", err);
2263 else if (trace->summary)
2264 trace__fprintf_thread_summary(trace, trace->output);
2267 perf_session__delete(session);
2272 static size_t trace__fprintf_threads_header(FILE *fp)
2276 printed = fprintf(fp, "\n Summary of events:\n\n");
2281 static size_t thread__dump_stats(struct thread_trace *ttrace,
2282 struct trace *trace, FILE *fp)
2284 struct stats *stats;
2287 struct int_node *inode = intlist__first(ttrace->syscall_stats);
2292 printed += fprintf(fp, "\n");
2294 printed += fprintf(fp, " syscall calls min avg max stddev\n");
2295 printed += fprintf(fp, " (msec) (msec) (msec) (%%)\n");
2296 printed += fprintf(fp, " --------------- -------- --------- --------- --------- ------\n");
2298 /* each int_node is a syscall */
2300 stats = inode->priv;
2302 double min = (double)(stats->min) / NSEC_PER_MSEC;
2303 double max = (double)(stats->max) / NSEC_PER_MSEC;
2304 double avg = avg_stats(stats);
2306 u64 n = (u64) stats->n;
2308 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2309 avg /= NSEC_PER_MSEC;
2311 sc = &trace->syscalls.table[inode->i];
2312 printed += fprintf(fp, " %-15s", sc->name);
2313 printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f",
2315 printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2318 inode = intlist__next(inode);
2321 printed += fprintf(fp, "\n\n");
2326 /* struct used to pass data to per-thread function */
2327 struct summary_data {
2329 struct trace *trace;
2333 static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2335 struct summary_data *data = priv;
2336 FILE *fp = data->fp;
2337 size_t printed = data->printed;
2338 struct trace *trace = data->trace;
2339 struct thread_trace *ttrace = thread->priv;
2345 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2347 printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2348 printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2349 printed += fprintf(fp, "%.1f%%", ratio);
2350 printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2351 printed += thread__dump_stats(ttrace, trace, fp);
2353 data->printed += printed;
2358 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2360 struct summary_data data = {
2364 data.printed = trace__fprintf_threads_header(fp);
2366 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2368 return data.printed;
2371 static int trace__set_duration(const struct option *opt, const char *str,
2372 int unset __maybe_unused)
2374 struct trace *trace = opt->value;
2376 trace->duration_filter = atof(str);
2380 static int trace__open_output(struct trace *trace, const char *filename)
2384 if (!stat(filename, &st) && st.st_size) {
2385 char oldname[PATH_MAX];
2387 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2389 rename(filename, oldname);
2392 trace->output = fopen(filename, "w");
2394 return trace->output == NULL ? -errno : 0;
2397 static int parse_pagefaults(const struct option *opt, const char *str,
2398 int unset __maybe_unused)
2400 int *trace_pgfaults = opt->value;
2402 if (strcmp(str, "all") == 0)
2403 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2404 else if (strcmp(str, "maj") == 0)
2405 *trace_pgfaults |= TRACE_PFMAJ;
2406 else if (strcmp(str, "min") == 0)
2407 *trace_pgfaults |= TRACE_PFMIN;
2414 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2416 const char * const trace_usage[] = {
2417 "perf trace [<options>] [<command>]",
2418 "perf trace [<options>] -- <command> [<options>]",
2419 "perf trace record [<options>] [<command>]",
2420 "perf trace record [<options>] -- <command> [<options>]",
2423 struct trace trace = {
2425 .machine = audit_detect_machine(),
2426 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2436 .user_freq = UINT_MAX,
2437 .user_interval = ULLONG_MAX,
2438 .no_buffering = true,
2444 const char *output_name = NULL;
2445 const char *ev_qualifier_str = NULL;
2446 const struct option trace_options[] = {
2447 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2448 "show the thread COMM next to its id"),
2449 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2450 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2451 "list of events to trace"),
2452 OPT_STRING('o', "output", &output_name, "file", "output file name"),
2453 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
2454 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2455 "trace events on existing process id"),
2456 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
2457 "trace events on existing thread id"),
2458 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
2459 "system-wide collection from all CPUs"),
2460 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
2461 "list of cpus to monitor"),
2462 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
2463 "child tasks do not inherit counters"),
2464 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2465 "number of mmap data pages",
2466 perf_evlist__parse_mmap_pages),
2467 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
2469 OPT_CALLBACK(0, "duration", &trace, "float",
2470 "show only events with duration > N.M ms",
2471 trace__set_duration),
2472 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
2473 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
2474 OPT_BOOLEAN('T', "time", &trace.full_time,
2475 "Show full timestamp, not time relative to first start"),
2476 OPT_BOOLEAN('s', "summary", &trace.summary_only,
2477 "Show only syscall summary with statistics"),
2478 OPT_BOOLEAN('S', "with-summary", &trace.summary,
2479 "Show all syscalls and summary with statistics"),
2480 OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
2481 "Trace pagefaults", parse_pagefaults, "maj"),
2487 argc = parse_options(argc, argv, trace_options, trace_usage,
2488 PARSE_OPT_STOP_AT_NON_OPTION);
2490 if (trace.trace_pgfaults) {
2491 trace.opts.sample_address = true;
2492 trace.opts.sample_time = true;
2495 if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
2496 return trace__record(&trace, argc-1, &argv[1]);
2498 /* summary_only implies summary option, but don't overwrite summary if set */
2499 if (trace.summary_only)
2500 trace.summary = trace.summary_only;
2502 if (output_name != NULL) {
2503 err = trace__open_output(&trace, output_name);
2505 perror("failed to create output file");
2510 if (ev_qualifier_str != NULL) {
2511 const char *s = ev_qualifier_str;
2513 trace.not_ev_qualifier = *s == '!';
2514 if (trace.not_ev_qualifier)
2516 trace.ev_qualifier = strlist__new(true, s);
2517 if (trace.ev_qualifier == NULL) {
2518 fputs("Not enough memory to parse event qualifier",
2525 err = target__validate(&trace.opts.target);
2527 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2528 fprintf(trace.output, "%s", bf);
2532 err = target__parse_uid(&trace.opts.target);
2534 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
2535 fprintf(trace.output, "%s", bf);
2539 if (!argc && target__none(&trace.opts.target))
2540 trace.opts.target.system_wide = true;
2543 err = trace__replay(&trace);
2545 err = trace__run(&trace, argc, argv);
2548 if (output_name != NULL)
2549 fclose(trace.output);