tools/perf/builtin-trace.c

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