projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf tools: Add new COMM infrastructure
[deliverable/linux.git] / tools / perf / builtin-trace.c
CommitLineData
4e319027 1#include <traceevent/event-parse.h>
514f1c67 2#include "builtin.h"
752fde44 3#include "util/color.h"
7c304ee0 4#include "util/debug.h"
514f1c67 5#include "util/evlist.h"
752fde44 6#include "util/machine.h"
6810fc91 7#include "util/session.h"
752fde44 8#include "util/thread.h"
514f1c67 9#include "util/parse-options.h"
2ae3a312 10#include "util/strlist.h"
bdc89661 11#include "util/intlist.h"
514f1c67 12#include "util/thread_map.h"
bf2575c1 13#include "util/stat.h"
514f1c67
ACM		 14
15#include <libaudit.h>
16#include <stdlib.h>
49af9e93 17#include <sys/eventfd.h>
ae685380 18#include <sys/mman.h>
f9da0b0c 19#include <linux/futex.h>
514f1c67 20
456857bd
IM		 21/* For older distros: */
22#ifndef MAP_STACK
23# define MAP_STACK 0x20000
24#endif
25
26#ifndef MADV_HWPOISON
27# define MADV_HWPOISON 100
28#endif
29
30#ifndef MADV_MERGEABLE
31# define MADV_MERGEABLE 12
32#endif
33
34#ifndef MADV_UNMERGEABLE
35# define MADV_UNMERGEABLE 13
36#endif
37
01533e97
ACM		 38struct syscall_arg {
39 unsigned long val;
75b757ca
ACM		 40 struct thread *thread;
41 struct trace *trace;
1f115cb7 42 void *parm;
01533e97
ACM		 43 u8 idx;
44 u8 mask;
45};
46
1f115cb7 47struct strarray {
03e3adc9 48 int offset;
1f115cb7
ACM		 49 int nr_entries;
50 const char **entries;
51};
52
53#define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
54 .nr_entries = ARRAY_SIZE(array), \
55 .entries = array, \
56}
57
03e3adc9
ACM		 58#define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
59 .offset = off, \
60 .nr_entries = ARRAY_SIZE(array), \
61 .entries = array, \
62}
63
975b7c2f
ACM		 64static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
65 const char *intfmt,
66 struct syscall_arg *arg)
1f115cb7 67{
1f115cb7 68 struct strarray *sa = arg->parm;
03e3adc9 69 int idx = arg->val - sa->offset;
1f115cb7
ACM		 70
71 if (idx < 0 || idx >= sa->nr_entries)
975b7c2f 72 return scnprintf(bf, size, intfmt, arg->val);
1f115cb7
ACM		 73
74 return scnprintf(bf, size, "%s", sa->entries[idx]);
75}
76
975b7c2f
ACM		 77static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
78 struct syscall_arg *arg)
79{
80 return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
81}
82
1f115cb7
ACM		 83#define SCA_STRARRAY syscall_arg__scnprintf_strarray
84
78645cf3
ACM		 85static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
86 struct syscall_arg *arg)
87{
88 return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
89}
90
91#define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
92
75b757ca
ACM		 93static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
94 struct syscall_arg *arg);
95
96#define SCA_FD syscall_arg__scnprintf_fd
97
98static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
99 struct syscall_arg *arg)
100{
101 int fd = arg->val;
102
103 if (fd == AT_FDCWD)
104 return scnprintf(bf, size, "CWD");
105
106 return syscall_arg__scnprintf_fd(bf, size, arg);
107}
108
109#define SCA_FDAT syscall_arg__scnprintf_fd_at
110
111static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
112 struct syscall_arg *arg);
113
114#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
115
6e7eeb51 116static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
01533e97 117 struct syscall_arg *arg)
13d4ff3e 118{
01533e97 119 return scnprintf(bf, size, "%#lx", arg->val);
13d4ff3e
ACM		 120}
121
beccb2b5
ACM		 122#define SCA_HEX syscall_arg__scnprintf_hex
123
6e7eeb51 124static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
01533e97 125 struct syscall_arg *arg)
ae685380 126{
01533e97 127 int printed = 0, prot = arg->val;
ae685380
ACM		 128
129 if (prot == PROT_NONE)
130 return scnprintf(bf, size, "NONE");
131#define P_MMAP_PROT(n) \
132 if (prot & PROT_##n) { \
133 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
134 prot &= ~PROT_##n; \
135 }
136
137 P_MMAP_PROT(EXEC);
138 P_MMAP_PROT(READ);
139 P_MMAP_PROT(WRITE);
140#ifdef PROT_SEM
141 P_MMAP_PROT(SEM);
142#endif
143 P_MMAP_PROT(GROWSDOWN);
144 P_MMAP_PROT(GROWSUP);
145#undef P_MMAP_PROT
146
147 if (prot)
148 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
149
150 return printed;
151}
152
153#define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
154
6e7eeb51 155static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
01533e97 156 struct syscall_arg *arg)
941557e0 157{
01533e97 158 int printed = 0, flags = arg->val;
941557e0
ACM		 159
160#define P_MMAP_FLAG(n) \
161 if (flags & MAP_##n) { \
162 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
163 flags &= ~MAP_##n; \
164 }
165
166 P_MMAP_FLAG(SHARED);
167 P_MMAP_FLAG(PRIVATE);
41817815 168#ifdef MAP_32BIT
941557e0 169 P_MMAP_FLAG(32BIT);
41817815 170#endif
941557e0
ACM		 171 P_MMAP_FLAG(ANONYMOUS);
172 P_MMAP_FLAG(DENYWRITE);
173 P_MMAP_FLAG(EXECUTABLE);
174 P_MMAP_FLAG(FILE);
175 P_MMAP_FLAG(FIXED);
176 P_MMAP_FLAG(GROWSDOWN);
f2935f3e 177#ifdef MAP_HUGETLB
941557e0 178 P_MMAP_FLAG(HUGETLB);
f2935f3e 179#endif
941557e0
ACM		 180 P_MMAP_FLAG(LOCKED);
181 P_MMAP_FLAG(NONBLOCK);
182 P_MMAP_FLAG(NORESERVE);
183 P_MMAP_FLAG(POPULATE);
184 P_MMAP_FLAG(STACK);
185#ifdef MAP_UNINITIALIZED
186 P_MMAP_FLAG(UNINITIALIZED);
187#endif
188#undef P_MMAP_FLAG
189
190 if (flags)
191 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
192
193 return printed;
194}
195
196#define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
197
6e7eeb51 198static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
01533e97 199 struct syscall_arg *arg)
9e9716d1 200{
01533e97 201 int behavior = arg->val;
9e9716d1
ACM		 202
203 switch (behavior) {
204#define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
205 P_MADV_BHV(NORMAL);
206 P_MADV_BHV(RANDOM);
207 P_MADV_BHV(SEQUENTIAL);
208 P_MADV_BHV(WILLNEED);
209 P_MADV_BHV(DONTNEED);
210 P_MADV_BHV(REMOVE);
211 P_MADV_BHV(DONTFORK);
212 P_MADV_BHV(DOFORK);
213 P_MADV_BHV(HWPOISON);
214#ifdef MADV_SOFT_OFFLINE
215 P_MADV_BHV(SOFT_OFFLINE);
216#endif
217 P_MADV_BHV(MERGEABLE);
218 P_MADV_BHV(UNMERGEABLE);
f2935f3e 219#ifdef MADV_HUGEPAGE
9e9716d1 220 P_MADV_BHV(HUGEPAGE);
f2935f3e
DA		 221#endif
222#ifdef MADV_NOHUGEPAGE
9e9716d1 223 P_MADV_BHV(NOHUGEPAGE);
f2935f3e 224#endif
9e9716d1
ACM		 225#ifdef MADV_DONTDUMP
226 P_MADV_BHV(DONTDUMP);
227#endif
228#ifdef MADV_DODUMP
229 P_MADV_BHV(DODUMP);
230#endif
231#undef P_MADV_PHV
232 default: break;
233 }
234
235 return scnprintf(bf, size, "%#x", behavior);
236}
237
238#define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
239
5cea6ff2
ACM		 240static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
241 struct syscall_arg *arg)
242{
243 int printed = 0, op = arg->val;
244
245 if (op == 0)
246 return scnprintf(bf, size, "NONE");
247#define P_CMD(cmd) \
248 if ((op & LOCK_##cmd) == LOCK_##cmd) { \
249 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
250 op &= ~LOCK_##cmd; \
251 }
252
253 P_CMD(SH);
254 P_CMD(EX);
255 P_CMD(NB);
256 P_CMD(UN);
257 P_CMD(MAND);
258 P_CMD(RW);
259 P_CMD(READ);
260 P_CMD(WRITE);
261#undef P_OP
262
263 if (op)
264 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
265
266 return printed;
267}
268
269#define SCA_FLOCK syscall_arg__scnprintf_flock
270
01533e97 271static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
f9da0b0c
ACM		 272{
273 enum syscall_futex_args {
274 SCF_UADDR = (1 << 0),
275 SCF_OP = (1 << 1),
276 SCF_VAL = (1 << 2),
277 SCF_TIMEOUT = (1 << 3),
278 SCF_UADDR2 = (1 << 4),
279 SCF_VAL3 = (1 << 5),
280 };
01533e97 281 int op = arg->val;
f9da0b0c
ACM		 282 int cmd = op & FUTEX_CMD_MASK;
283 size_t printed = 0;
284
285 switch (cmd) {
286#define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
01533e97
ACM		 287 P_FUTEX_OP(WAIT); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
288 P_FUTEX_OP(WAKE); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
289 P_FUTEX_OP(FD); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
290 P_FUTEX_OP(REQUEUE); arg->mask |= SCF_VAL3|SCF_TIMEOUT; break;
291 P_FUTEX_OP(CMP_REQUEUE); arg->mask |= SCF_TIMEOUT; break;
292 P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT; break;
f9da0b0c 293 P_FUTEX_OP(WAKE_OP); break;
01533e97
ACM		 294 P_FUTEX_OP(LOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
295 P_FUTEX_OP(UNLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
296 P_FUTEX_OP(TRYLOCK_PI); arg->mask |= SCF_VAL3|SCF_UADDR2; break;
297 P_FUTEX_OP(WAIT_BITSET); arg->mask |= SCF_UADDR2; break;
298 P_FUTEX_OP(WAKE_BITSET); arg->mask |= SCF_UADDR2; break;
f9da0b0c
ACM		 299 P_FUTEX_OP(WAIT_REQUEUE_PI); break;
300 default: printed = scnprintf(bf, size, "%#x", cmd); break;
301 }
302
303 if (op & FUTEX_PRIVATE_FLAG)
304 printed += scnprintf(bf + printed, size - printed, "|PRIV");
305
306 if (op & FUTEX_CLOCK_REALTIME)
307 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
308
309 return printed;
310}
311
efe6b882
ACM		 312#define SCA_FUTEX_OP syscall_arg__scnprintf_futex_op
313
03e3adc9
ACM		 314static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
315static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
eac032c5 316
1f115cb7
ACM		 317static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
318static DEFINE_STRARRAY(itimers);
319
efe6b882
ACM		 320static const char *whences[] = { "SET", "CUR", "END",
321#ifdef SEEK_DATA
322"DATA",
323#endif
324#ifdef SEEK_HOLE
325"HOLE",
326#endif
327};
328static DEFINE_STRARRAY(whences);
f9da0b0c 329
80f587d5
ACM		 330static const char *fcntl_cmds[] = {
331 "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
332 "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
333 "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
334 "F_GETOWNER_UIDS",
335};
336static DEFINE_STRARRAY(fcntl_cmds);
337
c045bf02
ACM		 338static const char *rlimit_resources[] = {
339 "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
340 "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
341 "RTTIME",
342};
343static DEFINE_STRARRAY(rlimit_resources);
344
eb5b1b14
ACM		 345static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
346static DEFINE_STRARRAY(sighow);
347
4f8c1b74
DA		 348static const char *clockid[] = {
349 "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
350 "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE",
351};
352static DEFINE_STRARRAY(clockid);
353
e10bce81
ACM		 354static const char *socket_families[] = {
355 "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
356 "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
357 "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
358 "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
359 "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
360 "ALG", "NFC", "VSOCK",
361};
362static DEFINE_STRARRAY(socket_families);
363
a28b24b2
ACM		 364#ifndef SOCK_TYPE_MASK
365#define SOCK_TYPE_MASK 0xf
366#endif
367
368static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
369 struct syscall_arg *arg)
370{
371 size_t printed;
372 int type = arg->val,
373 flags = type & ~SOCK_TYPE_MASK;
374
375 type &= SOCK_TYPE_MASK;
376 /*
377 * Can't use a strarray, MIPS may override for ABI reasons.
378 */
379 switch (type) {
380#define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
381 P_SK_TYPE(STREAM);
382 P_SK_TYPE(DGRAM);
383 P_SK_TYPE(RAW);
384 P_SK_TYPE(RDM);
385 P_SK_TYPE(SEQPACKET);
386 P_SK_TYPE(DCCP);
387 P_SK_TYPE(PACKET);
388#undef P_SK_TYPE
389 default:
390 printed = scnprintf(bf, size, "%#x", type);
391 }
392
393#define P_SK_FLAG(n) \
394 if (flags & SOCK_##n) { \
395 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
396 flags &= ~SOCK_##n; \
397 }
398
399 P_SK_FLAG(CLOEXEC);
400 P_SK_FLAG(NONBLOCK);
401#undef P_SK_FLAG
402
403 if (flags)
404 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
405
406 return printed;
407}
408
409#define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
410
b2cc99fd
ACM		 411#ifndef MSG_PROBE
412#define MSG_PROBE 0x10
413#endif
b6e8f8f4
DA		 414#ifndef MSG_WAITFORONE
415#define MSG_WAITFORONE 0x10000
416#endif
b2cc99fd
ACM		 417#ifndef MSG_SENDPAGE_NOTLAST
418#define MSG_SENDPAGE_NOTLAST 0x20000
419#endif
420#ifndef MSG_FASTOPEN
421#define MSG_FASTOPEN 0x20000000
422#endif
423
424static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
425 struct syscall_arg *arg)
426{
427 int printed = 0, flags = arg->val;
428
429 if (flags == 0)
430 return scnprintf(bf, size, "NONE");
431#define P_MSG_FLAG(n) \
432 if (flags & MSG_##n) { \
433 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
434 flags &= ~MSG_##n; \
435 }
436
437 P_MSG_FLAG(OOB);
438 P_MSG_FLAG(PEEK);
439 P_MSG_FLAG(DONTROUTE);
440 P_MSG_FLAG(TRYHARD);
441 P_MSG_FLAG(CTRUNC);
442 P_MSG_FLAG(PROBE);
443 P_MSG_FLAG(TRUNC);
444 P_MSG_FLAG(DONTWAIT);
445 P_MSG_FLAG(EOR);
446 P_MSG_FLAG(WAITALL);
447 P_MSG_FLAG(FIN);
448 P_MSG_FLAG(SYN);
449 P_MSG_FLAG(CONFIRM);
450 P_MSG_FLAG(RST);
451 P_MSG_FLAG(ERRQUEUE);
452 P_MSG_FLAG(NOSIGNAL);
453 P_MSG_FLAG(MORE);
454 P_MSG_FLAG(WAITFORONE);
455 P_MSG_FLAG(SENDPAGE_NOTLAST);
456 P_MSG_FLAG(FASTOPEN);
457 P_MSG_FLAG(CMSG_CLOEXEC);
458#undef P_MSG_FLAG
459
460 if (flags)
461 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
462
463 return printed;
464}
465
466#define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
467
51108999
ACM		 468static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
469 struct syscall_arg *arg)
470{
471 size_t printed = 0;
472 int mode = arg->val;
473
474 if (mode == F_OK) /* 0 */
475 return scnprintf(bf, size, "F");
476#define P_MODE(n) \
477 if (mode & n##_OK) { \
478 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
479 mode &= ~n##_OK; \
480 }
481
482 P_MODE(R);
483 P_MODE(W);
484 P_MODE(X);
485#undef P_MODE
486
487 if (mode)
488 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
489
490 return printed;
491}
492
493#define SCA_ACCMODE syscall_arg__scnprintf_access_mode
494
be65a89a 495static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
01533e97 496 struct syscall_arg *arg)
be65a89a 497{
01533e97 498 int printed = 0, flags = arg->val;
be65a89a
ACM		 499
500 if (!(flags & O_CREAT))
01533e97 501 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
be65a89a
ACM		 502
503 if (flags == 0)
504 return scnprintf(bf, size, "RDONLY");
505#define P_FLAG(n) \
506 if (flags & O_##n) { \
507 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
508 flags &= ~O_##n; \
509 }
510
511 P_FLAG(APPEND);
512 P_FLAG(ASYNC);
513 P_FLAG(CLOEXEC);
514 P_FLAG(CREAT);
515 P_FLAG(DIRECT);
516 P_FLAG(DIRECTORY);
517 P_FLAG(EXCL);
518 P_FLAG(LARGEFILE);
519 P_FLAG(NOATIME);
520 P_FLAG(NOCTTY);
521#ifdef O_NONBLOCK
522 P_FLAG(NONBLOCK);
523#elif O_NDELAY
524 P_FLAG(NDELAY);
525#endif
526#ifdef O_PATH
527 P_FLAG(PATH);
528#endif
529 P_FLAG(RDWR);
530#ifdef O_DSYNC
531 if ((flags & O_SYNC) == O_SYNC)
532 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
533 else {
534 P_FLAG(DSYNC);
535 }
536#else
537 P_FLAG(SYNC);
538#endif
539 P_FLAG(TRUNC);
540 P_FLAG(WRONLY);
541#undef P_FLAG
542
543 if (flags)
544 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
545
546 return printed;
547}
548
549#define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
550
49af9e93
ACM		 551static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
552 struct syscall_arg *arg)
553{
554 int printed = 0, flags = arg->val;
555
556 if (flags == 0)
557 return scnprintf(bf, size, "NONE");
558#define P_FLAG(n) \
559 if (flags & EFD_##n) { \
560 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
561 flags &= ~EFD_##n; \
562 }
563
564 P_FLAG(SEMAPHORE);
565 P_FLAG(CLOEXEC);
566 P_FLAG(NONBLOCK);
567#undef P_FLAG
568
569 if (flags)
570 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
571
572 return printed;
573}
574
575#define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
576
46cce19b
ACM		 577static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
578 struct syscall_arg *arg)
579{
580 int printed = 0, flags = arg->val;
581
582#define P_FLAG(n) \
583 if (flags & O_##n) { \
584 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
585 flags &= ~O_##n; \
586 }
587
588 P_FLAG(CLOEXEC);
589 P_FLAG(NONBLOCK);
590#undef P_FLAG
591
592 if (flags)
593 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
594
595 return printed;
596}
597
598#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
599
8bad5b0a
ACM		 600static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
601{
602 int sig = arg->val;
603
604 switch (sig) {
605#define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
606 P_SIGNUM(HUP);
607 P_SIGNUM(INT);
608 P_SIGNUM(QUIT);
609 P_SIGNUM(ILL);
610 P_SIGNUM(TRAP);
611 P_SIGNUM(ABRT);
612 P_SIGNUM(BUS);
613 P_SIGNUM(FPE);
614 P_SIGNUM(KILL);
615 P_SIGNUM(USR1);
616 P_SIGNUM(SEGV);
617 P_SIGNUM(USR2);
618 P_SIGNUM(PIPE);
619 P_SIGNUM(ALRM);
620 P_SIGNUM(TERM);
621 P_SIGNUM(STKFLT);
622 P_SIGNUM(CHLD);
623 P_SIGNUM(CONT);
624 P_SIGNUM(STOP);
625 P_SIGNUM(TSTP);
626 P_SIGNUM(TTIN);
627 P_SIGNUM(TTOU);
628 P_SIGNUM(URG);
629 P_SIGNUM(XCPU);
630 P_SIGNUM(XFSZ);
631 P_SIGNUM(VTALRM);
632 P_SIGNUM(PROF);
633 P_SIGNUM(WINCH);
634 P_SIGNUM(IO);
635 P_SIGNUM(PWR);
636 P_SIGNUM(SYS);
637 default: break;
638 }
639
640 return scnprintf(bf, size, "%#x", sig);
641}
642
643#define SCA_SIGNUM syscall_arg__scnprintf_signum
644
78645cf3
ACM		 645#define TCGETS 0x5401
646
647static const char *tioctls[] = {
648 "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
649 "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
650 "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
651 "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
652 "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
653 "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
654 "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
655 "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
656 "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
657 "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
658 "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
659 [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
660 "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
661 "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
662 "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
663};
664
665static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
666
453350dd
ACM		 667#define STRARRAY(arg, name, array) \
668 .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
669 .arg_parm = { [arg] = &strarray__##array, }
670
514f1c67
ACM		 671static struct syscall_fmt {
672 const char *name;
aec1930b 673 const char *alias;
01533e97 674 size_t (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
1f115cb7 675 void *arg_parm[6];
514f1c67
ACM		 676 bool errmsg;
677 bool timeout;
04b34729 678 bool hexret;
514f1c67 679} syscall_fmts[] = {
51108999
ACM		 680 { .name = "access", .errmsg = true,
681 .arg_scnprintf = { [1] = SCA_ACCMODE, /* mode */ }, },
aec1930b 682 { .name = "arch_prctl", .errmsg = true, .alias = "prctl", },
beccb2b5
ACM		 683 { .name = "brk", .hexret = true,
684 .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
4f8c1b74 685 { .name = "clock_gettime", .errmsg = true, STRARRAY(0, clk_id, clockid), },
75b757ca
ACM		 686 { .name = "close", .errmsg = true,
687 .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
a14bb860 688 { .name = "connect", .errmsg = true, },
75b757ca
ACM		 689 { .name = "dup", .errmsg = true,
690 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
691 { .name = "dup2", .errmsg = true,
692 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
693 { .name = "dup3", .errmsg = true,
694 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd 695 { .name = "epoll_ctl", .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
49af9e93
ACM		 696 { .name = "eventfd2", .errmsg = true,
697 .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
75b757ca
ACM		 698 { .name = "faccessat", .errmsg = true,
699 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
700 { .name = "fadvise64", .errmsg = true,
701 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
702 { .name = "fallocate", .errmsg = true,
703 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
704 { .name = "fchdir", .errmsg = true,
705 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
706 { .name = "fchmod", .errmsg = true,
707 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
708 { .name = "fchmodat", .errmsg = true,
709 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
710 { .name = "fchown", .errmsg = true,
711 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
712 { .name = "fchownat", .errmsg = true,
713 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
714 { .name = "fcntl", .errmsg = true,
715 .arg_scnprintf = { [0] = SCA_FD, /* fd */
716 [1] = SCA_STRARRAY, /* cmd */ },
717 .arg_parm = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
718 { .name = "fdatasync", .errmsg = true,
719 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
5cea6ff2 720 { .name = "flock", .errmsg = true,
75b757ca
ACM		 721 .arg_scnprintf = { [0] = SCA_FD, /* fd */
722 [1] = SCA_FLOCK, /* cmd */ }, },
723 { .name = "fsetxattr", .errmsg = true,
724 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
725 { .name = "fstat", .errmsg = true, .alias = "newfstat",
726 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
727 { .name = "fstatat", .errmsg = true, .alias = "newfstatat",
728 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
729 { .name = "fstatfs", .errmsg = true,
730 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
731 { .name = "fsync", .errmsg = true,
732 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
733 { .name = "ftruncate", .errmsg = true,
734 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
f9da0b0c
ACM		 735 { .name = "futex", .errmsg = true,
736 .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
75b757ca
ACM		 737 { .name = "futimesat", .errmsg = true,
738 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
739 { .name = "getdents", .errmsg = true,
740 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
741 { .name = "getdents64", .errmsg = true,
742 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd
ACM		 743 { .name = "getitimer", .errmsg = true, STRARRAY(0, which, itimers), },
744 { .name = "getrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
beccb2b5 745 { .name = "ioctl", .errmsg = true,
75b757ca 746 .arg_scnprintf = { [0] = SCA_FD, /* fd */
78645cf3
ACM		 747 [1] = SCA_STRHEXARRAY, /* cmd */
748 [2] = SCA_HEX, /* arg */ },
749 .arg_parm = { [1] = &strarray__tioctls, /* cmd */ }, },
8bad5b0a
ACM		 750 { .name = "kill", .errmsg = true,
751 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
75b757ca
ACM		 752 { .name = "linkat", .errmsg = true,
753 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
754 { .name = "lseek", .errmsg = true,
755 .arg_scnprintf = { [0] = SCA_FD, /* fd */
756 [2] = SCA_STRARRAY, /* whence */ },
757 .arg_parm = { [2] = &strarray__whences, /* whence */ }, },
e5959683 758 { .name = "lstat", .errmsg = true, .alias = "newlstat", },
9e9716d1
ACM		 759 { .name = "madvise", .errmsg = true,
760 .arg_scnprintf = { [0] = SCA_HEX, /* start */
761 [2] = SCA_MADV_BHV, /* behavior */ }, },
75b757ca
ACM		 762 { .name = "mkdirat", .errmsg = true,
763 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
764 { .name = "mknodat", .errmsg = true,
765 .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
3d903aa7
ACM		 766 { .name = "mlock", .errmsg = true,
767 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
768 { .name = "mlockall", .errmsg = true,
769 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
beccb2b5 770 { .name = "mmap", .hexret = true,
ae685380 771 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
941557e0
ACM		 772 [2] = SCA_MMAP_PROT, /* prot */
773 [3] = SCA_MMAP_FLAGS, /* flags */ }, },
beccb2b5 774 { .name = "mprotect", .errmsg = true,
ae685380
ACM		 775 .arg_scnprintf = { [0] = SCA_HEX, /* start */
776 [2] = SCA_MMAP_PROT, /* prot */ }, },
777 { .name = "mremap", .hexret = true,
778 .arg_scnprintf = { [0] = SCA_HEX, /* addr */
779 [4] = SCA_HEX, /* new_addr */ }, },
3d903aa7
ACM		 780 { .name = "munlock", .errmsg = true,
781 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
beccb2b5
ACM		 782 { .name = "munmap", .errmsg = true,
783 .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
75b757ca
ACM		 784 { .name = "name_to_handle_at", .errmsg = true,
785 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
786 { .name = "newfstatat", .errmsg = true,
787 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
be65a89a
ACM		 788 { .name = "open", .errmsg = true,
789 .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
31cd3855 790 { .name = "open_by_handle_at", .errmsg = true,
75b757ca
ACM		 791 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
792 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
31cd3855 793 { .name = "openat", .errmsg = true,
75b757ca
ACM		 794 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
795 [2] = SCA_OPEN_FLAGS, /* flags */ }, },
46cce19b
ACM		 796 { .name = "pipe2", .errmsg = true,
797 .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
aec1930b
ACM		 798 { .name = "poll", .errmsg = true, .timeout = true, },
799 { .name = "ppoll", .errmsg = true, .timeout = true, },
75b757ca
ACM		 800 { .name = "pread", .errmsg = true, .alias = "pread64",
801 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
802 { .name = "preadv", .errmsg = true, .alias = "pread",
803 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
453350dd 804 { .name = "prlimit64", .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
75b757ca
ACM		 805 { .name = "pwrite", .errmsg = true, .alias = "pwrite64",
806 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
807 { .name = "pwritev", .errmsg = true,
808 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
809 { .name = "read", .errmsg = true,
810 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
811 { .name = "readlinkat", .errmsg = true,
812 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
813 { .name = "readv", .errmsg = true,
814 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
b2cc99fd
ACM		 815 { .name = "recvfrom", .errmsg = true,
816 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
817 { .name = "recvmmsg", .errmsg = true,
818 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
819 { .name = "recvmsg", .errmsg = true,
820 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
75b757ca
ACM		 821 { .name = "renameat", .errmsg = true,
822 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
8bad5b0a
ACM		 823 { .name = "rt_sigaction", .errmsg = true,
824 .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
453350dd 825 { .name = "rt_sigprocmask", .errmsg = true, STRARRAY(0, how, sighow), },
8bad5b0a
ACM		 826 { .name = "rt_sigqueueinfo", .errmsg = true,
827 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
828 { .name = "rt_tgsigqueueinfo", .errmsg = true,
829 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
aec1930b 830 { .name = "select", .errmsg = true, .timeout = true, },
b2cc99fd
ACM		 831 { .name = "sendmmsg", .errmsg = true,
832 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
833 { .name = "sendmsg", .errmsg = true,
834 .arg_scnprintf = { [2] = SCA_MSG_FLAGS, /* flags */ }, },
835 { .name = "sendto", .errmsg = true,
836 .arg_scnprintf = { [3] = SCA_MSG_FLAGS, /* flags */ }, },
453350dd
ACM		 837 { .name = "setitimer", .errmsg = true, STRARRAY(0, which, itimers), },
838 { .name = "setrlimit", .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
75b757ca
ACM		 839 { .name = "shutdown", .errmsg = true,
840 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
e10bce81 841 { .name = "socket", .errmsg = true,
a28b24b2
ACM		 842 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
843 [1] = SCA_SK_TYPE, /* type */ },
07120aa5
ACM		 844 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
845 { .name = "socketpair", .errmsg = true,
846 .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
847 [1] = SCA_SK_TYPE, /* type */ },
e10bce81 848 .arg_parm = { [0] = &strarray__socket_families, /* family */ }, },
aec1930b 849 { .name = "stat", .errmsg = true, .alias = "newstat", },
75b757ca
ACM		 850 { .name = "symlinkat", .errmsg = true,
851 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
8bad5b0a
ACM		 852 { .name = "tgkill", .errmsg = true,
853 .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
854 { .name = "tkill", .errmsg = true,
855 .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
e5959683 856 { .name = "uname", .errmsg = true, .alias = "newuname", },
75b757ca
ACM		 857 { .name = "unlinkat", .errmsg = true,
858 .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
859 { .name = "utimensat", .errmsg = true,
860 .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */ }, },
861 { .name = "write", .errmsg = true,
862 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
863 { .name = "writev", .errmsg = true,
864 .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
514f1c67
ACM		 865};
866
867static int syscall_fmt__cmp(const void *name, const void *fmtp)
868{
869 const struct syscall_fmt *fmt = fmtp;
870 return strcmp(name, fmt->name);
871}
872
873static struct syscall_fmt *syscall_fmt__find(const char *name)
874{
875 const int nmemb = ARRAY_SIZE(syscall_fmts);
876 return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
877}
878
879struct syscall {
880 struct event_format *tp_format;
881 const char *name;
2ae3a312 882 bool filtered;
514f1c67 883 struct syscall_fmt *fmt;
01533e97 884 size_t (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1f115cb7 885 void **arg_parm;
514f1c67
ACM		 886};
887
60c907ab
ACM		 888static size_t fprintf_duration(unsigned long t, FILE *fp)
889{
890 double duration = (double)t / NSEC_PER_MSEC;
891 size_t printed = fprintf(fp, "(");
892
893 if (duration >= 1.0)
894 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
895 else if (duration >= 0.01)
896 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
897 else
898 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
c24ff998 899 return printed + fprintf(fp, "): ");
60c907ab
ACM		 900}
901
752fde44
ACM		 902struct thread_trace {
903 u64 entry_time;
904 u64 exit_time;
905 bool entry_pending;
efd5745e 906 unsigned long nr_events;
752fde44 907 char *entry_str;
1302d88e 908 double runtime_ms;
75b757ca
ACM		 909 struct {
910 int max;
911 char **table;
912 } paths;
bf2575c1
DA		 913
914 struct intlist *syscall_stats;
752fde44
ACM		 915};
916
917static struct thread_trace *thread_trace__new(void)
918{
75b757ca
ACM		 919 struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));
920
921 if (ttrace)
922 ttrace->paths.max = -1;
923
bf2575c1
DA		 924 ttrace->syscall_stats = intlist__new(NULL);
925
75b757ca 926 return ttrace;
752fde44
ACM		 927}
928
c24ff998 929static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
752fde44 930{
efd5745e
ACM		 931 struct thread_trace *ttrace;
932
752fde44
ACM		 933 if (thread == NULL)
934 goto fail;
935
936 if (thread->priv == NULL)
937 thread->priv = thread_trace__new();
efd5745e 938
752fde44
ACM		 939 if (thread->priv == NULL)
940 goto fail;
941
efd5745e
ACM		 942 ttrace = thread->priv;
943 ++ttrace->nr_events;
944
945 return ttrace;
752fde44 946fail:
c24ff998 947 color_fprintf(fp, PERF_COLOR_RED,
752fde44
ACM		 948 "WARNING: not enough memory, dropping samples!\n");
949 return NULL;
950}
951
514f1c67 952struct trace {
c24ff998 953 struct perf_tool tool;
c522739d
ACM		 954 struct {
955 int machine;
956 int open_id;
957 } audit;
514f1c67
ACM		 958 struct {
959 int max;
960 struct syscall *table;
961 } syscalls;
962 struct perf_record_opts opts;
8fb598e5 963 struct machine *host;
752fde44 964 u64 base_time;
4bb09192 965 bool full_time;
c24ff998 966 FILE *output;
efd5745e 967 unsigned long nr_events;
b059efdf
ACM		 968 struct strlist *ev_qualifier;
969 bool not_ev_qualifier;
75b757ca 970 bool live;
c522739d 971 const char *last_vfs_getname;
bdc89661
DA		 972 struct intlist *tid_list;
973 struct intlist *pid_list;
1302d88e 974 bool sched;
752fde44 975 bool multiple_threads;
bf2575c1 976 bool summary;
50c95cbd 977 bool show_comm;
c522739d 978 bool show_tool_stats;
ae9ed035 979 double duration_filter;
1302d88e 980 double runtime_ms;
c522739d
ACM		 981 struct {
982 u64 vfs_getname, proc_getname;
983 } stats;
514f1c67
ACM		 984};
985
97119f37 986static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
75b757ca
ACM		 987{
988 struct thread_trace *ttrace = thread->priv;
75b757ca
ACM		 989
990 if (fd > ttrace->paths.max) {
991 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
992
993 if (npath == NULL)
994 return -1;
995
996 if (ttrace->paths.max != -1) {
997 memset(npath + ttrace->paths.max + 1, 0,
998 (fd - ttrace->paths.max) * sizeof(char *));
999 } else {
1000 memset(npath, 0, (fd + 1) * sizeof(char *));
1001 }
1002
1003 ttrace->paths.table = npath;
1004 ttrace->paths.max = fd;
1005 }
1006
1007 ttrace->paths.table[fd] = strdup(pathname);
1008
1009 return ttrace->paths.table[fd] != NULL ? 0 : -1;
1010}
1011
97119f37
ACM		 1012static int thread__read_fd_path(struct thread *thread, int fd)
1013{
1014 char linkname[PATH_MAX], pathname[PATH_MAX];
1015 struct stat st;
1016 int ret;
1017
1018 if (thread->pid_ == thread->tid) {
1019 scnprintf(linkname, sizeof(linkname),
1020 "/proc/%d/fd/%d", thread->pid_, fd);
1021 } else {
1022 scnprintf(linkname, sizeof(linkname),
1023 "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1024 }
1025
1026 if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1027 return -1;
1028
1029 ret = readlink(linkname, pathname, sizeof(pathname));
1030
1031 if (ret < 0 || ret > st.st_size)
1032 return -1;
1033
1034 pathname[ret] = '\0';
1035 return trace__set_fd_pathname(thread, fd, pathname);
1036}
1037
c522739d
ACM		 1038static const char *thread__fd_path(struct thread *thread, int fd,
1039 struct trace *trace)
75b757ca
ACM		 1040{
1041 struct thread_trace *ttrace = thread->priv;
1042
1043 if (ttrace == NULL)
1044 return NULL;
1045
1046 if (fd < 0)
1047 return NULL;
1048
c522739d
ACM		 1049 if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL))
1050 if (!trace->live)
1051 return NULL;
1052 ++trace->stats.proc_getname;
1053 if (thread__read_fd_path(thread, fd)) {
1054 return NULL;
1055 }
75b757ca
ACM		 1056
1057 return ttrace->paths.table[fd];
1058}
1059
1060static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1061 struct syscall_arg *arg)
1062{
1063 int fd = arg->val;
1064 size_t printed = scnprintf(bf, size, "%d", fd);
c522739d 1065 const char *path = thread__fd_path(arg->thread, fd, arg->trace);
75b757ca
ACM		 1066
1067 if (path)
1068 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1069
1070 return printed;
1071}
1072
1073static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1074 struct syscall_arg *arg)
1075{
1076 int fd = arg->val;
1077 size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1078 struct thread_trace *ttrace = arg->thread->priv;
1079
1080 if (ttrace && fd >= 0 && fd <= ttrace->paths.max) {
1081 free(ttrace->paths.table[fd]);
1082 ttrace->paths.table[fd] = NULL;
1083 }
1084
1085 return printed;
1086}
1087
ae9ed035
ACM		 1088static bool trace__filter_duration(struct trace *trace, double t)
1089{
1090 return t < (trace->duration_filter * NSEC_PER_MSEC);
1091}
1092
752fde44
ACM		 1093static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1094{
1095 double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1096
60c907ab 1097 return fprintf(fp, "%10.3f ", ts);
752fde44
ACM		 1098}
1099
f15eb531 1100static bool done = false;
ba209f85 1101static bool interrupted = false;
f15eb531 1102
ba209f85 1103static void sig_handler(int sig)
f15eb531
NK		 1104{
1105 done = true;
ba209f85 1106 interrupted = sig == SIGINT;
f15eb531
NK		 1107}
1108
752fde44 1109static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
60c907ab 1110 u64 duration, u64 tstamp, FILE *fp)
752fde44
ACM		 1111{
1112 size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
60c907ab 1113 printed += fprintf_duration(duration, fp);
752fde44 1114
50c95cbd
ACM		 1115 if (trace->multiple_threads) {
1116 if (trace->show_comm)
1902efe7 1117 printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
38051234 1118 printed += fprintf(fp, "%d ", thread->tid);
50c95cbd 1119 }
752fde44
ACM		 1120
1121 return printed;
1122}
1123
c24ff998 1124static int trace__process_event(struct trace *trace, struct machine *machine,
162f0bef 1125 union perf_event *event, struct perf_sample *sample)
752fde44
ACM		 1126{
1127 int ret = 0;
1128
1129 switch (event->header.type) {
1130 case PERF_RECORD_LOST:
c24ff998 1131 color_fprintf(trace->output, PERF_COLOR_RED,
752fde44 1132 "LOST %" PRIu64 " events!\n", event->lost.lost);
162f0bef 1133 ret = machine__process_lost_event(machine, event, sample);
752fde44 1134 default:
162f0bef 1135 ret = machine__process_event(machine, event, sample);
752fde44
ACM		 1136 break;
1137 }
1138
1139 return ret;
1140}
1141
c24ff998 1142static int trace__tool_process(struct perf_tool *tool,
752fde44 1143 union perf_event *event,
162f0bef 1144 struct perf_sample *sample,
752fde44
ACM		 1145 struct machine *machine)
1146{
c24ff998 1147 struct trace *trace = container_of(tool, struct trace, tool);
162f0bef 1148 return trace__process_event(trace, machine, event, sample);
752fde44
ACM		 1149}
1150
1151static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1152{
1153 int err = symbol__init();
1154
1155 if (err)
1156 return err;
1157
8fb598e5
DA		 1158 trace->host = machine__new_host();
1159 if (trace->host == NULL)
1160 return -ENOMEM;
752fde44
ACM		 1161
1162 if (perf_target__has_task(&trace->opts.target)) {
c24ff998 1163 err = perf_event__synthesize_thread_map(&trace->tool, evlist->threads,
752fde44 1164 trace__tool_process,
8fb598e5 1165 trace->host);
752fde44 1166 } else {
c24ff998 1167 err = perf_event__synthesize_threads(&trace->tool, trace__tool_process,
8fb598e5 1168 trace->host);
752fde44
ACM		 1169 }
1170
1171 if (err)
1172 symbol__exit();
1173
1174 return err;
1175}
1176
13d4ff3e
ACM		 1177static int syscall__set_arg_fmts(struct syscall *sc)
1178{
1179 struct format_field *field;
1180 int idx = 0;
1181
1182 sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
1183 if (sc->arg_scnprintf == NULL)
1184 return -1;
1185
1f115cb7
ACM		 1186 if (sc->fmt)
1187 sc->arg_parm = sc->fmt->arg_parm;
1188
13d4ff3e 1189 for (field = sc->tp_format->format.fields->next; field; field = field->next) {
beccb2b5
ACM		 1190 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1191 sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1192 else if (field->flags & FIELD_IS_POINTER)
13d4ff3e
ACM		 1193 sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1194 ++idx;
1195 }
1196
1197 return 0;
1198}
1199
514f1c67
ACM		 1200static int trace__read_syscall_info(struct trace *trace, int id)
1201{
1202 char tp_name[128];
1203 struct syscall *sc;
c522739d 1204 const char *name = audit_syscall_to_name(id, trace->audit.machine);
3a531260
ACM		 1205
1206 if (name == NULL)
1207 return -1;
514f1c67
ACM		 1208
1209 if (id > trace->syscalls.max) {
1210 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1211
1212 if (nsyscalls == NULL)
1213 return -1;
1214
1215 if (trace->syscalls.max != -1) {
1216 memset(nsyscalls + trace->syscalls.max + 1, 0,
1217 (id - trace->syscalls.max) * sizeof(*sc));
1218 } else {
1219 memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1220 }
1221
1222 trace->syscalls.table = nsyscalls;
1223 trace->syscalls.max = id;
1224 }
1225
1226 sc = trace->syscalls.table + id;
3a531260 1227 sc->name = name;
2ae3a312 1228
b059efdf
ACM		 1229 if (trace->ev_qualifier) {
1230 bool in = strlist__find(trace->ev_qualifier, name) != NULL;
1231
1232 if (!(in ^ trace->not_ev_qualifier)) {
1233 sc->filtered = true;
1234 /*
1235 * No need to do read tracepoint information since this will be
1236 * filtered out.
1237 */
1238 return 0;
1239 }
2ae3a312
ACM		 1240 }
1241
3a531260 1242 sc->fmt = syscall_fmt__find(sc->name);
514f1c67 1243
aec1930b 1244 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
514f1c67 1245 sc->tp_format = event_format__new("syscalls", tp_name);
aec1930b
ACM		 1246
1247 if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1248 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1249 sc->tp_format = event_format__new("syscalls", tp_name);
1250 }
514f1c67 1251
13d4ff3e
ACM		 1252 if (sc->tp_format == NULL)
1253 return -1;
1254
1255 return syscall__set_arg_fmts(sc);
514f1c67
ACM		 1256}
1257
752fde44 1258static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
75b757ca
ACM		 1259 unsigned long *args, struct trace *trace,
1260 struct thread *thread)
514f1c67 1261{
514f1c67
ACM		 1262 size_t printed = 0;
1263
1264 if (sc->tp_format != NULL) {
1265 struct format_field *field;
01533e97
ACM		 1266 u8 bit = 1;
1267 struct syscall_arg arg = {
75b757ca
ACM		 1268 .idx = 0,
1269 .mask = 0,
1270 .trace = trace,
1271 .thread = thread,
01533e97 1272 };
6e7eeb51
ACM		 1273
1274 for (field = sc->tp_format->format.fields->next; field;
01533e97
ACM		 1275 field = field->next, ++arg.idx, bit <<= 1) {
1276 if (arg.mask & bit)
6e7eeb51 1277 continue;
4aa58232
ACM		 1278 /*
1279 * Suppress this argument if its value is zero and
1280 * and we don't have a string associated in an
1281 * strarray for it.
1282 */
1283 if (args[arg.idx] == 0 &&
1284 !(sc->arg_scnprintf &&
1285 sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1286 sc->arg_parm[arg.idx]))
22ae5cf1
ACM		 1287 continue;
1288
752fde44 1289 printed += scnprintf(bf + printed, size - printed,
13d4ff3e 1290 "%s%s: ", printed ? ", " : "", field->name);
01533e97
ACM		 1291 if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1292 arg.val = args[arg.idx];
1f115cb7
ACM		 1293 if (sc->arg_parm)
1294 arg.parm = sc->arg_parm[arg.idx];
01533e97
ACM		 1295 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1296 size - printed, &arg);
6e7eeb51 1297 } else {
13d4ff3e 1298 printed += scnprintf(bf + printed, size - printed,
01533e97 1299 "%ld", args[arg.idx]);
6e7eeb51 1300 }
514f1c67
ACM		 1301 }
1302 } else {
01533e97
ACM		 1303 int i = 0;
1304
514f1c67 1305 while (i < 6) {
752fde44
ACM		 1306 printed += scnprintf(bf + printed, size - printed,
1307 "%sarg%d: %ld",
1308 printed ? ", " : "", i, args[i]);
514f1c67
ACM		 1309 ++i;
1310 }
1311 }
1312
1313 return printed;
1314}
1315
ba3d7dee
ACM		 1316typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1317 struct perf_sample *sample);
1318
1319static struct syscall *trace__syscall_info(struct trace *trace,
bf2575c1 1320 struct perf_evsel *evsel, int id)
ba3d7dee 1321{
ba3d7dee
ACM		 1322
1323 if (id < 0) {
adaa18bf
ACM		 1324
1325 /*
1326 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1327 * before that, leaving at a higher verbosity level till that is
1328 * explained. Reproduced with plain ftrace with:
1329 *
1330 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1331 * grep "NR -1 " /t/trace_pipe
1332 *
1333 * After generating some load on the machine.
1334 */
1335 if (verbose > 1) {
1336 static u64 n;
1337 fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1338 id, perf_evsel__name(evsel), ++n);
1339 }
ba3d7dee
ACM		 1340 return NULL;
1341 }
1342
1343 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1344 trace__read_syscall_info(trace, id))
1345 goto out_cant_read;
1346
1347 if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1348 goto out_cant_read;
1349
1350 return &trace->syscalls.table[id];
1351
1352out_cant_read:
7c304ee0
ACM		 1353 if (verbose) {
1354 fprintf(trace->output, "Problems reading syscall %d", id);
1355 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1356 fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1357 fputs(" information\n", trace->output);
1358 }
ba3d7dee
ACM		 1359 return NULL;
1360}
1361
bf2575c1
DA		 1362static void thread__update_stats(struct thread_trace *ttrace,
1363 int id, struct perf_sample *sample)
1364{
1365 struct int_node *inode;
1366 struct stats *stats;
1367 u64 duration = 0;
1368
1369 inode = intlist__findnew(ttrace->syscall_stats, id);
1370 if (inode == NULL)
1371 return;
1372
1373 stats = inode->priv;
1374 if (stats == NULL) {
1375 stats = malloc(sizeof(struct stats));
1376 if (stats == NULL)
1377 return;
1378 init_stats(stats);
1379 inode->priv = stats;
1380 }
1381
1382 if (ttrace->entry_time && sample->time > ttrace->entry_time)
1383 duration = sample->time - ttrace->entry_time;
1384
1385 update_stats(stats, duration);
1386}
1387
ba3d7dee
ACM		 1388static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1389 struct perf_sample *sample)
1390{
752fde44 1391 char *msg;
ba3d7dee 1392 void *args;
752fde44 1393 size_t printed = 0;
2ae3a312 1394 struct thread *thread;
bf2575c1
DA		 1395 int id = perf_evsel__intval(evsel, sample, "id");
1396 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1397 struct thread_trace *ttrace;
1398
1399 if (sc == NULL)
1400 return -1;
ba3d7dee 1401
2ae3a312
ACM		 1402 if (sc->filtered)
1403 return 0;
1404
8fb598e5 1405 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1406 ttrace = thread__trace(thread, trace->output);
2ae3a312 1407 if (ttrace == NULL)
ba3d7dee
ACM		 1408 return -1;
1409
1410 args = perf_evsel__rawptr(evsel, sample, "args");
1411 if (args == NULL) {
c24ff998 1412 fprintf(trace->output, "Problems reading syscall arguments\n");
ba3d7dee
ACM		 1413 return -1;
1414 }
1415
752fde44
ACM		 1416 ttrace = thread->priv;
1417
1418 if (ttrace->entry_str == NULL) {
1419 ttrace->entry_str = malloc(1024);
1420 if (!ttrace->entry_str)
1421 return -1;
1422 }
1423
1424 ttrace->entry_time = sample->time;
1425 msg = ttrace->entry_str;
1426 printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
1427
75b757ca
ACM		 1428 printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,
1429 args, trace, thread);
752fde44
ACM		 1430
1431 if (!strcmp(sc->name, "exit_group") || !strcmp(sc->name, "exit")) {
ae9ed035 1432 if (!trace->duration_filter) {
c24ff998
ACM		 1433 trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1434 fprintf(trace->output, "%-70s\n", ttrace->entry_str);
ae9ed035 1435 }
752fde44
ACM		 1436 } else
1437 ttrace->entry_pending = true;
ba3d7dee
ACM		 1438
1439 return 0;
1440}
1441
1442static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1443 struct perf_sample *sample)
1444{
1445 int ret;
60c907ab 1446 u64 duration = 0;
2ae3a312 1447 struct thread *thread;
bf2575c1
DA		 1448 int id = perf_evsel__intval(evsel, sample, "id");
1449 struct syscall *sc = trace__syscall_info(trace, evsel, id);
2ae3a312
ACM		 1450 struct thread_trace *ttrace;
1451
1452 if (sc == NULL)
1453 return -1;
ba3d7dee 1454
2ae3a312
ACM		 1455 if (sc->filtered)
1456 return 0;
1457
8fb598e5 1458 thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
c24ff998 1459 ttrace = thread__trace(thread, trace->output);
2ae3a312 1460 if (ttrace == NULL)
ba3d7dee
ACM		 1461 return -1;
1462
bf2575c1
DA		 1463 if (trace->summary)
1464 thread__update_stats(ttrace, id, sample);
1465
ba3d7dee
ACM		 1466 ret = perf_evsel__intval(evsel, sample, "ret");
1467
c522739d
ACM		 1468 if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
1469 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
1470 trace->last_vfs_getname = NULL;
1471 ++trace->stats.vfs_getname;
1472 }
1473
752fde44
ACM		 1474 ttrace = thread->priv;
1475
1476 ttrace->exit_time = sample->time;
1477
ae9ed035 1478 if (ttrace->entry_time) {
60c907ab 1479 duration = sample->time - ttrace->entry_time;
ae9ed035
ACM		 1480 if (trace__filter_duration(trace, duration))
1481 goto out;
1482 } else if (trace->duration_filter)
1483 goto out;
60c907ab 1484
c24ff998 1485 trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
752fde44
ACM		 1486
1487 if (ttrace->entry_pending) {
c24ff998 1488 fprintf(trace->output, "%-70s", ttrace->entry_str);
752fde44 1489 } else {
c24ff998
ACM		 1490 fprintf(trace->output, " ... [");
1491 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
1492 fprintf(trace->output, "]: %s()", sc->name);
752fde44
ACM		 1493 }
1494
da3c9a44
ACM		 1495 if (sc->fmt == NULL) {
1496signed_print:
1497 fprintf(trace->output, ") = %d", ret);
1498 } else if (ret < 0 && sc->fmt->errmsg) {
ba3d7dee
ACM		 1499 char bf[256];
1500 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
1501 *e = audit_errno_to_name(-ret);
1502
c24ff998 1503 fprintf(trace->output, ") = -1 %s %s", e, emsg);
da3c9a44 1504 } else if (ret == 0 && sc->fmt->timeout)
c24ff998 1505 fprintf(trace->output, ") = 0 Timeout");
04b34729
ACM		 1506 else if (sc->fmt->hexret)
1507 fprintf(trace->output, ") = %#x", ret);
ba3d7dee 1508 else
da3c9a44 1509 goto signed_print;
ba3d7dee 1510
c24ff998 1511 fputc('\n', trace->output);
ae9ed035 1512out:
752fde44
ACM		 1513 ttrace->entry_pending = false;
1514
ba3d7dee
ACM		 1515 return 0;
1516}
1517
c522739d
ACM		 1518static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
1519 struct perf_sample *sample)
1520{
1521 trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
1522 return 0;
1523}
1524
1302d88e
ACM		 1525static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
1526 struct perf_sample *sample)
1527{
1528 u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
1529 double runtime_ms = (double)runtime / NSEC_PER_MSEC;
8fb598e5 1530 struct thread *thread = machine__findnew_thread(trace->host,
314add6b
AH		 1531 sample->pid,
1532 sample->tid);
c24ff998 1533 struct thread_trace *ttrace = thread__trace(thread, trace->output);
1302d88e
ACM		 1534
1535 if (ttrace == NULL)
1536 goto out_dump;
1537
1538 ttrace->runtime_ms += runtime_ms;
1539 trace->runtime_ms += runtime_ms;
1540 return 0;
1541
1542out_dump:
c24ff998 1543 fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
1302d88e
ACM		 1544 evsel->name,
1545 perf_evsel__strval(evsel, sample, "comm"),
1546 (pid_t)perf_evsel__intval(evsel, sample, "pid"),
1547 runtime,
1548 perf_evsel__intval(evsel, sample, "vruntime"));
1549 return 0;
1550}
1551
bdc89661
DA		 1552static bool skip_sample(struct trace *trace, struct perf_sample *sample)
1553{
1554 if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
1555 (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
1556 return false;
1557
1558 if (trace->pid_list || trace->tid_list)
1559 return true;
1560
1561 return false;
1562}
1563
6810fc91
DA		 1564static int trace__process_sample(struct perf_tool *tool,
1565 union perf_event *event __maybe_unused,
1566 struct perf_sample *sample,
1567 struct perf_evsel *evsel,
1568 struct machine *machine __maybe_unused)
1569{
1570 struct trace *trace = container_of(tool, struct trace, tool);
1571 int err = 0;
1572
1573 tracepoint_handler handler = evsel->handler.func;
1574
bdc89661
DA		 1575 if (skip_sample(trace, sample))
1576 return 0;
1577
4bb09192 1578 if (!trace->full_time && trace->base_time == 0)
6810fc91
DA		 1579 trace->base_time = sample->time;
1580
1581 if (handler)
1582 handler(trace, evsel, sample);
1583
1584 return err;
1585}
1586
1587static bool
1588perf_session__has_tp(struct perf_session *session, const char *name)
1589{
1590 struct perf_evsel *evsel;
1591
1592 evsel = perf_evlist__find_tracepoint_by_name(session->evlist, name);
1593
1594 return evsel != NULL;
1595}
1596
bdc89661
DA		 1597static int parse_target_str(struct trace *trace)
1598{
1599 if (trace->opts.target.pid) {
1600 trace->pid_list = intlist__new(trace->opts.target.pid);
1601 if (trace->pid_list == NULL) {
1602 pr_err("Error parsing process id string\n");
1603 return -EINVAL;
1604 }
1605 }
1606
1607 if (trace->opts.target.tid) {
1608 trace->tid_list = intlist__new(trace->opts.target.tid);
1609 if (trace->tid_list == NULL) {
1610 pr_err("Error parsing thread id string\n");
1611 return -EINVAL;
1612 }
1613 }
1614
1615 return 0;
1616}
1617
5e2485b1
DA		 1618static int trace__record(int argc, const char **argv)
1619{
1620 unsigned int rec_argc, i, j;
1621 const char **rec_argv;
1622 const char * const record_args[] = {
1623 "record",
1624 "-R",
1625 "-m", "1024",
1626 "-c", "1",
1627 "-e", "raw_syscalls:sys_enter,raw_syscalls:sys_exit",
1628 };
1629
1630 rec_argc = ARRAY_SIZE(record_args) + argc;
1631 rec_argv = calloc(rec_argc + 1, sizeof(char *));
1632
1633 if (rec_argv == NULL)
1634 return -ENOMEM;
1635
1636 for (i = 0; i < ARRAY_SIZE(record_args); i++)
1637 rec_argv[i] = record_args[i];
1638
1639 for (j = 0; j < (unsigned int)argc; j++, i++)
1640 rec_argv[i] = argv[j];
1641
1642 return cmd_record(i, rec_argv, NULL);
1643}
1644
bf2575c1
DA		 1645static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
1646
c522739d
ACM		 1647static void perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
1648{
1649 struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname",
1650 evlist->nr_entries);
1651 if (evsel == NULL)
1652 return;
1653
1654 if (perf_evsel__field(evsel, "pathname") == NULL) {
1655 perf_evsel__delete(evsel);
1656 return;
1657 }
1658
1659 evsel->handler.func = trace__vfs_getname;
1660 perf_evlist__add(evlist, evsel);
1661}
1662
f15eb531 1663static int trace__run(struct trace *trace, int argc, const char **argv)
514f1c67 1664{
334fe7a3 1665 struct perf_evlist *evlist = perf_evlist__new();
ba3d7dee 1666 struct perf_evsel *evsel;
efd5745e
ACM		 1667 int err = -1, i;
1668 unsigned long before;
f15eb531 1669 const bool forks = argc > 0;
514f1c67 1670
75b757ca
ACM		 1671 trace->live = true;
1672
514f1c67 1673 if (evlist == NULL) {
c24ff998 1674 fprintf(trace->output, "Not enough memory to run!\n");
514f1c67
ACM		 1675 goto out;
1676 }
1677
39876e7d 1678 if (perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_enter", trace__sys_enter) ||
87f91868
RR		 1679 perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit))
1680 goto out_error_tp;
514f1c67 1681
c522739d
ACM		 1682 perf_evlist__add_vfs_getname(evlist);
1683
1302d88e 1684 if (trace->sched &&
87f91868
RR		 1685 perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
1686 trace__sched_stat_runtime))
1687 goto out_error_tp;
1302d88e 1688
514f1c67
ACM		 1689 err = perf_evlist__create_maps(evlist, &trace->opts.target);
1690 if (err < 0) {
c24ff998 1691 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
514f1c67
ACM		 1692 goto out_delete_evlist;
1693 }
1694
752fde44
ACM		 1695 err = trace__symbols_init(trace, evlist);
1696 if (err < 0) {
c24ff998 1697 fprintf(trace->output, "Problems initializing symbol libraries!\n");
3beb0861 1698 goto out_delete_maps;
752fde44
ACM		 1699 }
1700
f77a9518 1701 perf_evlist__config(evlist, &trace->opts);
514f1c67 1702
f15eb531
NK		 1703 signal(SIGCHLD, sig_handler);
1704 signal(SIGINT, sig_handler);
1705
1706 if (forks) {
6ef73ec4 1707 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
55e162ea 1708 argv, false, false);
f15eb531 1709 if (err < 0) {
c24ff998 1710 fprintf(trace->output, "Couldn't run the workload!\n");
3beb0861 1711 goto out_delete_maps;
f15eb531
NK		 1712 }
1713 }
1714
514f1c67 1715 err = perf_evlist__open(evlist);
a8f23d8f
ACM		 1716 if (err < 0)
1717 goto out_error_open;
514f1c67
ACM		 1718
1719 err = perf_evlist__mmap(evlist, UINT_MAX, false);
1720 if (err < 0) {
c24ff998 1721 fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
3beb0861 1722 goto out_close_evlist;
514f1c67
ACM		 1723 }
1724
1725 perf_evlist__enable(evlist);
f15eb531
NK		 1726
1727 if (forks)
1728 perf_evlist__start_workload(evlist);
1729
752fde44 1730 trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
514f1c67 1731again:
efd5745e 1732 before = trace->nr_events;
514f1c67
ACM		 1733
1734 for (i = 0; i < evlist->nr_mmaps; i++) {
1735 union perf_event *event;
1736
1737 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
1738 const u32 type = event->header.type;
ba3d7dee 1739 tracepoint_handler handler;
514f1c67 1740 struct perf_sample sample;
514f1c67 1741
efd5745e 1742 ++trace->nr_events;
514f1c67 1743
514f1c67
ACM		 1744 err = perf_evlist__parse_sample(evlist, event, &sample);
1745 if (err) {
c24ff998 1746 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
8e50d384 1747 goto next_event;
514f1c67
ACM		 1748 }
1749
4bb09192 1750 if (!trace->full_time && trace->base_time == 0)
752fde44
ACM		 1751 trace->base_time = sample.time;
1752
1753 if (type != PERF_RECORD_SAMPLE) {
162f0bef 1754 trace__process_event(trace, trace->host, event, &sample);
752fde44
ACM		 1755 continue;
1756 }
1757
514f1c67
ACM		 1758 evsel = perf_evlist__id2evsel(evlist, sample.id);
1759 if (evsel == NULL) {
c24ff998 1760 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
8e50d384 1761 goto next_event;
514f1c67
ACM		 1762 }
1763
fc551f8d 1764 if (sample.raw_data == NULL) {
c24ff998 1765 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
fc551f8d
ACM		 1766 perf_evsel__name(evsel), sample.tid,
1767 sample.cpu, sample.raw_size);
8e50d384 1768 goto next_event;
fc551f8d
ACM		 1769 }
1770
ba3d7dee
ACM		 1771 handler = evsel->handler.func;
1772 handler(trace, evsel, &sample);
8e50d384
ZZ		 1773next_event:
1774 perf_evlist__mmap_consume(evlist, i);
20c5f10e 1775
ba209f85
ACM		 1776 if (interrupted)
1777 goto out_disable;
514f1c67
ACM		 1778 }
1779 }
1780
efd5745e 1781 if (trace->nr_events == before) {
ba209f85 1782 int timeout = done ? 100 : -1;
f15eb531 1783
ba209f85
ACM		 1784 if (poll(evlist->pollfd, evlist->nr_fds, timeout) > 0)
1785 goto again;
1786 } else {
1787 goto again;
f15eb531
NK		 1788 }
1789
ba209f85
ACM		 1790out_disable:
1791 perf_evlist__disable(evlist);
514f1c67 1792
c522739d
ACM		 1793 if (!err) {
1794 if (trace->summary)
1795 trace__fprintf_thread_summary(trace, trace->output);
1796
1797 if (trace->show_tool_stats) {
1798 fprintf(trace->output, "Stats:\n "
1799 " vfs_getname : %" PRIu64 "\n"
1800 " proc_getname: %" PRIu64 "\n",
1801 trace->stats.vfs_getname,
1802 trace->stats.proc_getname);
1803 }
1804 }
bf2575c1 1805
3beb0861
NK		 1806 perf_evlist__munmap(evlist);
1807out_close_evlist:
1808 perf_evlist__close(evlist);
1809out_delete_maps:
1810 perf_evlist__delete_maps(evlist);
514f1c67
ACM		 1811out_delete_evlist:
1812 perf_evlist__delete(evlist);
1813out:
75b757ca 1814 trace->live = false;
514f1c67 1815 return err;
6ef068cb
ACM		 1816{
1817 char errbuf[BUFSIZ];
a8f23d8f
ACM		 1818
1819out_error_tp:
6ef068cb 1820 perf_evlist__strerror_tp(evlist, errno, errbuf, sizeof(errbuf));
a8f23d8f
ACM		 1821 goto out_error;
1822
1823out_error_open:
1824 perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
1825
1826out_error:
6ef068cb 1827 fprintf(trace->output, "%s\n", errbuf);
87f91868 1828 goto out_delete_evlist;
514f1c67 1829}
a8f23d8f 1830}
514f1c67 1831
6810fc91
DA		 1832static int trace__replay(struct trace *trace)
1833{
1834 const struct perf_evsel_str_handler handlers[] = {
1835 { "raw_syscalls:sys_enter", trace__sys_enter, },
1836 { "raw_syscalls:sys_exit", trace__sys_exit, },
c522739d 1837 { "probe:vfs_getname", trace__vfs_getname, },
6810fc91 1838 };
f5fc1412
JO		 1839 struct perf_data_file file = {
1840 .path = input_name,
1841 .mode = PERF_DATA_MODE_READ,
1842 };
6810fc91
DA		 1843 struct perf_session *session;
1844 int err = -1;
1845
1846 trace->tool.sample = trace__process_sample;
1847 trace->tool.mmap = perf_event__process_mmap;
384c671e 1848 trace->tool.mmap2 = perf_event__process_mmap2;
6810fc91
DA		 1849 trace->tool.comm = perf_event__process_comm;
1850 trace->tool.exit = perf_event__process_exit;
1851 trace->tool.fork = perf_event__process_fork;
1852 trace->tool.attr = perf_event__process_attr;
1853 trace->tool.tracing_data = perf_event__process_tracing_data;
1854 trace->tool.build_id = perf_event__process_build_id;
1855
1856 trace->tool.ordered_samples = true;
1857 trace->tool.ordering_requires_timestamps = true;
1858
1859 /* add tid to output */
1860 trace->multiple_threads = true;
1861
1862 if (symbol__init() < 0)
1863 return -1;
1864
f5fc1412 1865 session = perf_session__new(&file, false, &trace->tool);
6810fc91
DA		 1866 if (session == NULL)
1867 return -ENOMEM;
1868
8fb598e5
DA		 1869 trace->host = &session->machines.host;
1870
6810fc91
DA		 1871 err = perf_session__set_tracepoints_handlers(session, handlers);
1872 if (err)
1873 goto out;
1874
1875 if (!perf_session__has_tp(session, "raw_syscalls:sys_enter")) {
1876 pr_err("Data file does not have raw_syscalls:sys_enter events\n");
1877 goto out;
1878 }
1879
1880 if (!perf_session__has_tp(session, "raw_syscalls:sys_exit")) {
1881 pr_err("Data file does not have raw_syscalls:sys_exit events\n");
1882 goto out;
1883 }
1884
bdc89661
DA		 1885 err = parse_target_str(trace);
1886 if (err != 0)
1887 goto out;
1888
6810fc91
DA		 1889 setup_pager();
1890
1891 err = perf_session__process_events(session, &trace->tool);
1892 if (err)
1893 pr_err("Failed to process events, error %d", err);
1894
bf2575c1
DA		 1895 else if (trace->summary)
1896 trace__fprintf_thread_summary(trace, trace->output);
1897
6810fc91
DA		 1898out:
1899 perf_session__delete(session);
1900
1901 return err;
1902}
1903
1302d88e
ACM		 1904static size_t trace__fprintf_threads_header(FILE *fp)
1905{
1906 size_t printed;
1907
bf2575c1
DA		 1908 printed = fprintf(fp, "\n _____________________________________________________________________________\n");
1909 printed += fprintf(fp, " __) Summary of events (__\n\n");
1910 printed += fprintf(fp, " [ task - pid ] [ events ] [ ratio ] [ runtime ]\n");
1911 printed += fprintf(fp, " syscall count min max avg stddev\n");
1912 printed += fprintf(fp, " msec msec msec %%\n");
1913 printed += fprintf(fp, " _____________________________________________________________________________\n\n");
1914
1915 return printed;
1916}
1917
1918static size_t thread__dump_stats(struct thread_trace *ttrace,
1919 struct trace *trace, FILE *fp)
1920{
1921 struct stats *stats;
1922 size_t printed = 0;
1923 struct syscall *sc;
1924 struct int_node *inode = intlist__first(ttrace->syscall_stats);
1925
1926 if (inode == NULL)
1927 return 0;
1928
1929 printed += fprintf(fp, "\n");
1930
1931 /* each int_node is a syscall */
1932 while (inode) {
1933 stats = inode->priv;
1934 if (stats) {
1935 double min = (double)(stats->min) / NSEC_PER_MSEC;
1936 double max = (double)(stats->max) / NSEC_PER_MSEC;
1937 double avg = avg_stats(stats);
1938 double pct;
1939 u64 n = (u64) stats->n;
1940
1941 pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
1942 avg /= NSEC_PER_MSEC;
1943
1944 sc = &trace->syscalls.table[inode->i];
1945 printed += fprintf(fp, "%24s %14s : ", "", sc->name);
1946 printed += fprintf(fp, "%5" PRIu64 " %8.3f %8.3f",
1947 n, min, max);
1948 printed += fprintf(fp, " %8.3f %6.2f\n", avg, pct);
1949 }
1950
1951 inode = intlist__next(inode);
1952 }
1953
1954 printed += fprintf(fp, "\n\n");
1302d88e
ACM		 1955
1956 return printed;
1957}
1958
896cbb56
DA		 1959/* struct used to pass data to per-thread function */
1960struct summary_data {
1961 FILE *fp;
1962 struct trace *trace;
1963 size_t printed;
1964};
1965
1966static int trace__fprintf_one_thread(struct thread *thread, void *priv)
1967{
1968 struct summary_data *data = priv;
1969 FILE *fp = data->fp;
1970 size_t printed = data->printed;
1971 struct trace *trace = data->trace;
1972 struct thread_trace *ttrace = thread->priv;
1973 const char *color;
1974 double ratio;
1975
1976 if (ttrace == NULL)
1977 return 0;
1978
1979 ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
1980
1981 color = PERF_COLOR_NORMAL;
1982 if (ratio > 50.0)
1983 color = PERF_COLOR_RED;
1984 else if (ratio > 25.0)
1985 color = PERF_COLOR_GREEN;
1986 else if (ratio > 5.0)
1987 color = PERF_COLOR_YELLOW;
1988
1902efe7 1989 printed += color_fprintf(fp, color, "%20s", thread__comm_str(thread));
896cbb56
DA		 1990 printed += fprintf(fp, " - %-5d :%11lu [", thread->tid, ttrace->nr_events);
1991 printed += color_fprintf(fp, color, "%5.1f%%", ratio);
1992 printed += fprintf(fp, " ] %10.3f ms\n", ttrace->runtime_ms);
bf2575c1 1993 printed += thread__dump_stats(ttrace, trace, fp);
896cbb56
DA		 1994
1995 data->printed += printed;
1996
1997 return 0;
1998}
1999
1302d88e
ACM		 2000static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2001{
896cbb56
DA		 2002 struct summary_data data = {
2003 .fp = fp,
2004 .trace = trace
2005 };
2006 data.printed = trace__fprintf_threads_header(fp);
1302d88e 2007
896cbb56
DA		 2008 machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2009
2010 return data.printed;
1302d88e
ACM		 2011}
2012
ae9ed035
ACM		 2013static int trace__set_duration(const struct option *opt, const char *str,
2014 int unset __maybe_unused)
2015{
2016 struct trace *trace = opt->value;
2017
2018 trace->duration_filter = atof(str);
2019 return 0;
2020}
2021
c24ff998
ACM		 2022static int trace__open_output(struct trace *trace, const char *filename)
2023{
2024 struct stat st;
2025
2026 if (!stat(filename, &st) && st.st_size) {
2027 char oldname[PATH_MAX];
2028
2029 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2030 unlink(oldname);
2031 rename(filename, oldname);
2032 }
2033
2034 trace->output = fopen(filename, "w");
2035
2036 return trace->output == NULL ? -errno : 0;
2037}
2038
514f1c67
ACM		 2039int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2040{
2041 const char * const trace_usage[] = {
f15eb531
NK		 2042 "perf trace [<options>] [<command>]",
2043 "perf trace [<options>] -- <command> [<options>]",
5e2485b1
DA		 2044 "perf trace record [<options>] [<command>]",
2045 "perf trace record [<options>] -- <command> [<options>]",
514f1c67
ACM		 2046 NULL
2047 };
2048 struct trace trace = {
c522739d
ACM		 2049 .audit = {
2050 .machine = audit_detect_machine(),
2051 .open_id = audit_name_to_syscall("open", trace.audit.machine),
2052 },
514f1c67
ACM		 2053 .syscalls = {
2054 . max = -1,
2055 },
2056 .opts = {
2057 .target = {
2058 .uid = UINT_MAX,
2059 .uses_mmap = true,
2060 },
2061 .user_freq = UINT_MAX,
2062 .user_interval = ULLONG_MAX,
2063 .no_delay = true,
2064 .mmap_pages = 1024,
2065 },
c24ff998 2066 .output = stdout,
50c95cbd 2067 .show_comm = true,
514f1c67 2068 };
c24ff998 2069 const char *output_name = NULL;
2ae3a312 2070 const char *ev_qualifier_str = NULL;
514f1c67 2071 const struct option trace_options[] = {
50c95cbd
ACM		 2072 OPT_BOOLEAN(0, "comm", &trace.show_comm,
2073 "show the thread COMM next to its id"),
c522739d 2074 OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
2ae3a312
ACM		 2075 OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
2076 "list of events to trace"),
c24ff998 2077 OPT_STRING('o', "output", &output_name, "file", "output file name"),
6810fc91 2078 OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
514f1c67
ACM		 2079 OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
2080 "trace events on existing process id"),
ac9be8ee 2081 OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
514f1c67 2082 "trace events on existing thread id"),
ac9be8ee 2083 OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
514f1c67 2084 "system-wide collection from all CPUs"),
ac9be8ee 2085 OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
514f1c67 2086 "list of cpus to monitor"),
6810fc91 2087 OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
514f1c67 2088 "child tasks do not inherit counters"),
994a1f78
JO		 2089 OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
2090 "number of mmap data pages",
2091 perf_evlist__parse_mmap_pages),
ac9be8ee 2092 OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
514f1c67 2093 "user to profile"),
ae9ed035
ACM		 2094 OPT_CALLBACK(0, "duration", &trace, "float",
2095 "show only events with duration > N.M ms",
2096 trace__set_duration),
1302d88e 2097 OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
7c304ee0 2098 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
4bb09192
DA		 2099 OPT_BOOLEAN('T', "time", &trace.full_time,
2100 "Show full timestamp, not time relative to first start"),
bf2575c1
DA		 2101 OPT_BOOLEAN(0, "summary", &trace.summary,
2102 "Show syscall summary with statistics"),
514f1c67
ACM		 2103 OPT_END()
2104 };
2105 int err;
32caf0d1 2106 char bf[BUFSIZ];
514f1c67 2107
5e2485b1
DA		 2108 if ((argc > 1) && (strcmp(argv[1], "record") == 0))
2109 return trace__record(argc-2, &argv[2]);
2110
514f1c67 2111 argc = parse_options(argc, argv, trace_options, trace_usage, 0);
514f1c67 2112
c24ff998
ACM		 2113 if (output_name != NULL) {
2114 err = trace__open_output(&trace, output_name);
2115 if (err < 0) {
2116 perror("failed to create output file");
2117 goto out;
2118 }
2119 }
2120
2ae3a312 2121 if (ev_qualifier_str != NULL) {
b059efdf
ACM		 2122 const char *s = ev_qualifier_str;
2123
2124 trace.not_ev_qualifier = *s == '!';
2125 if (trace.not_ev_qualifier)
2126 ++s;
2127 trace.ev_qualifier = strlist__new(true, s);
2ae3a312 2128 if (trace.ev_qualifier == NULL) {
c24ff998
ACM		 2129 fputs("Not enough memory to parse event qualifier",
2130 trace.output);
2131 err = -ENOMEM;
2132 goto out_close;
2ae3a312
ACM		 2133 }
2134 }
2135
32caf0d1
NK		 2136 err = perf_target__validate(&trace.opts.target);
2137 if (err) {
2138 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2139 fprintf(trace.output, "%s", bf);
2140 goto out_close;
32caf0d1
NK		 2141 }
2142
514f1c67
ACM		 2143 err = perf_target__parse_uid(&trace.opts.target);
2144 if (err) {
514f1c67 2145 perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
c24ff998
ACM		 2146 fprintf(trace.output, "%s", bf);
2147 goto out_close;
514f1c67
ACM		 2148 }
2149
f15eb531 2150 if (!argc && perf_target__none(&trace.opts.target))
ee76120e
NK		 2151 trace.opts.target.system_wide = true;
2152
6810fc91
DA		 2153 if (input_name)
2154 err = trace__replay(&trace);
2155 else
2156 err = trace__run(&trace, argc, argv);
1302d88e 2157
c24ff998
ACM		 2158out_close:
2159 if (output_name != NULL)
2160 fclose(trace.output);
2161out:
1302d88e 2162 return err;
514f1c67 2163}
Linux kernel - Deliverables
This page took 0.163688 seconds and 5 git commands to generate.