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/exec_cmd.h"
   7 #include "util/machine.h"
   8 #include "util/session.h"
   9 #include "util/thread.h"
  10 #include "util/parse-options.h"
  11 #include "util/strlist.h"
  12 #include "util/intlist.h"
  13 #include "util/thread_map.h"
  14 #include "util/stat.h"
  15 #include "trace-event.h"
  16 #include "util/parse-events.h"
  17
  18 #include <libaudit.h>
  19 #include <stdlib.h>
  20 #include <sys/mman.h>
  21 #include <linux/futex.h>
  22
  23 /* For older distros: */
  24 #ifndef MAP_STACK
  25 # define MAP_STACK              0x20000
  26 #endif
  27
  28 #ifndef MADV_HWPOISON
  29 # define MADV_HWPOISON          100
  30 #endif
  31
  32 #ifndef MADV_MERGEABLE
  33 # define MADV_MERGEABLE         12
  34 #endif
  35
  36 #ifndef MADV_UNMERGEABLE
  37 # define MADV_UNMERGEABLE       13
  38 #endif
  39
  40 #ifndef EFD_SEMAPHORE
  41 # define EFD_SEMAPHORE          1
  42 #endif
  43
  44 #ifndef EFD_NONBLOCK
  45 # define EFD_NONBLOCK           00004000
  46 #endif
  47
  48 #ifndef EFD_CLOEXEC
  49 # define EFD_CLOEXEC            02000000
  50 #endif
  51
  52 #ifndef O_CLOEXEC
  53 # define O_CLOEXEC              02000000
  54 #endif
  55
  56 #ifndef SOCK_DCCP
  57 # define SOCK_DCCP              6
  58 #endif
  59
  60 #ifndef SOCK_CLOEXEC
  61 # define SOCK_CLOEXEC           02000000
  62 #endif
  63
  64 #ifndef SOCK_NONBLOCK
  65 # define SOCK_NONBLOCK          00004000
  66 #endif
  67
  68 #ifndef MSG_CMSG_CLOEXEC
  69 # define MSG_CMSG_CLOEXEC       0x40000000
  70 #endif
  71
  72 #ifndef PERF_FLAG_FD_NO_GROUP
  73 # define PERF_FLAG_FD_NO_GROUP          (1UL << 0)
  74 #endif
  75
  76 #ifndef PERF_FLAG_FD_OUTPUT
  77 # define PERF_FLAG_FD_OUTPUT            (1UL << 1)
  78 #endif
  79
  80 #ifndef PERF_FLAG_PID_CGROUP
  81 # define PERF_FLAG_PID_CGROUP           (1UL << 2) /* pid=cgroup id, per-cpu mode only */
  82 #endif
  83
  84 #ifndef PERF_FLAG_FD_CLOEXEC
  85 # define PERF_FLAG_FD_CLOEXEC           (1UL << 3) /* O_CLOEXEC */
  86 #endif
  87
  88
  89 struct tp_field {
  90         int offset;
  91         union {
  92                 u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
  93                 void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
  94         };
  95 };
  96
  97 #define TP_UINT_FIELD(bits) \
  98 static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
  99 { \
 100         u##bits value; \
 101         memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 102         return value;  \
 103 }
 104
 105 TP_UINT_FIELD(8);
 106 TP_UINT_FIELD(16);
 107 TP_UINT_FIELD(32);
 108 TP_UINT_FIELD(64);
 109
 110 #define TP_UINT_FIELD__SWAPPED(bits) \
 111 static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
 112 { \
 113         u##bits value; \
 114         memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 115         return bswap_##bits(value);\
 116 }
 117
 118 TP_UINT_FIELD__SWAPPED(16);
 119 TP_UINT_FIELD__SWAPPED(32);
 120 TP_UINT_FIELD__SWAPPED(64);
 121
 122 static int tp_field__init_uint(struct tp_field *field,
 123                                struct format_field *format_field,
 124                                bool needs_swap)
 125 {
 126         field->offset = format_field->offset;
 127
 128         switch (format_field->size) {
 129         case 1:
 130                 field->integer = tp_field__u8;
 131                 break;
 132         case 2:
 133                 field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
 134                 break;
 135         case 4:
 136                 field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
 137                 break;
 138         case 8:
 139                 field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
 140                 break;
 141         default:
 142                 return -1;
 143         }
 144
 145         return 0;
 146 }
 147
 148 static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
 149 {
 150         return sample->raw_data + field->offset;
 151 }
 152
 153 static int tp_field__init_ptr(struct tp_field *field, struct format_field *format_field)
 154 {
 155         field->offset = format_field->offset;
 156         field->pointer = tp_field__ptr;
 157         return 0;
 158 }
 159
 160 struct syscall_tp {
 161         struct tp_field id;
 162         union {
 163                 struct tp_field args, ret;
 164         };
 165 };
 166
 167 static int perf_evsel__init_tp_uint_field(struct perf_evsel *evsel,
 168                                           struct tp_field *field,
 169                                           const char *name)
 170 {
 171         struct format_field *format_field = perf_evsel__field(evsel, name);
 172
 173         if (format_field == NULL)
 174                 return -1;
 175
 176         return tp_field__init_uint(field, format_field, evsel->needs_swap);
 177 }
 178
 179 #define perf_evsel__init_sc_tp_uint_field(evsel, name) \
 180         ({ struct syscall_tp *sc = evsel->priv;\
 181            perf_evsel__init_tp_uint_field(evsel, &sc->name, #name); })
 182
 183 static int perf_evsel__init_tp_ptr_field(struct perf_evsel *evsel,
 184                                          struct tp_field *field,
 185                                          const char *name)
 186 {
 187         struct format_field *format_field = perf_evsel__field(evsel, name);
 188
 189         if (format_field == NULL)
 190                 return -1;
 191
 192         return tp_field__init_ptr(field, format_field);
 193 }
 194
 195 #define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
 196         ({ struct syscall_tp *sc = evsel->priv;\
 197            perf_evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
 198
 199 static void perf_evsel__delete_priv(struct perf_evsel *evsel)
 200 {
 201         zfree(&evsel->priv);
 202         perf_evsel__delete(evsel);
 203 }
 204
 205 static int perf_evsel__init_syscall_tp(struct perf_evsel *evsel, void *handler)
 206 {
 207         evsel->priv = malloc(sizeof(struct syscall_tp));
 208         if (evsel->priv != NULL) {
 209                 if (perf_evsel__init_sc_tp_uint_field(evsel, id))
 210                         goto out_delete;
 211
 212                 evsel->handler = handler;
 213                 return 0;
 214         }
 215
 216         return -ENOMEM;
 217
 218 out_delete:
 219         zfree(&evsel->priv);
 220         return -ENOENT;
 221 }
 222
 223 static struct perf_evsel *perf_evsel__syscall_newtp(const char *direction, void *handler)
 224 {
 225         struct perf_evsel *evsel = perf_evsel__newtp("raw_syscalls", direction);
 226
 227         /* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
 228         if (evsel == NULL)
 229                 evsel = perf_evsel__newtp("syscalls", direction);
 230
 231         if (evsel) {
 232                 if (perf_evsel__init_syscall_tp(evsel, handler))
 233                         goto out_delete;
 234         }
 235
 236         return evsel;
 237
 238 out_delete:
 239         perf_evsel__delete_priv(evsel);
 240         return NULL;
 241 }
 242
 243 #define perf_evsel__sc_tp_uint(evsel, name, sample) \
 244         ({ struct syscall_tp *fields = evsel->priv; \
 245            fields->name.integer(&fields->name, sample); })
 246
 247 #define perf_evsel__sc_tp_ptr(evsel, name, sample) \
 248         ({ struct syscall_tp *fields = evsel->priv; \
 249            fields->name.pointer(&fields->name, sample); })
 250
 251 struct syscall_arg {
 252         unsigned long val;
 253         struct thread *thread;
 254         struct trace  *trace;
 255         void          *parm;
 256         u8            idx;
 257         u8            mask;
 258 };
 259
 260 struct strarray {
 261         int         offset;
 262         int         nr_entries;
 263         const char **entries;
 264 };
 265
 266 #define DEFINE_STRARRAY(array) struct strarray strarray__##array = { \
 267         .nr_entries = ARRAY_SIZE(array), \
 268         .entries = array, \
 269 }
 270
 271 #define DEFINE_STRARRAY_OFFSET(array, off) struct strarray strarray__##array = { \
 272         .offset     = off, \
 273         .nr_entries = ARRAY_SIZE(array), \
 274         .entries = array, \
 275 }
 276
 277 static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
 278                                                 const char *intfmt,
 279                                                 struct syscall_arg *arg)
 280 {
 281         struct strarray *sa = arg->parm;
 282         int idx = arg->val - sa->offset;
 283
 284         if (idx < 0 || idx >= sa->nr_entries)
 285                 return scnprintf(bf, size, intfmt, arg->val);
 286
 287         return scnprintf(bf, size, "%s", sa->entries[idx]);
 288 }
 289
 290 static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
 291                                               struct syscall_arg *arg)
 292 {
 293         return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
 294 }
 295
 296 #define SCA_STRARRAY syscall_arg__scnprintf_strarray
 297
 298 #if defined(__i386__) || defined(__x86_64__)
 299 /*
 300  * FIXME: Make this available to all arches as soon as the ioctl beautifier
 301  *        gets rewritten to support all arches.
 302  */
 303 static size_t syscall_arg__scnprintf_strhexarray(char *bf, size_t size,
 304                                                  struct syscall_arg *arg)
 305 {
 306         return __syscall_arg__scnprintf_strarray(bf, size, "%#x", arg);
 307 }
 308
 309 #define SCA_STRHEXARRAY syscall_arg__scnprintf_strhexarray
 310 #endif /* defined(__i386__) || defined(__x86_64__) */
 311
 312 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
 313                                         struct syscall_arg *arg);
 314
 315 #define SCA_FD syscall_arg__scnprintf_fd
 316
 317 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
 318                                            struct syscall_arg *arg)
 319 {
 320         int fd = arg->val;
 321
 322         if (fd == AT_FDCWD)
 323                 return scnprintf(bf, size, "CWD");
 324
 325         return syscall_arg__scnprintf_fd(bf, size, arg);
 326 }
 327
 328 #define SCA_FDAT syscall_arg__scnprintf_fd_at
 329
 330 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
 331                                               struct syscall_arg *arg);
 332
 333 #define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
 334
 335 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
 336                                          struct syscall_arg *arg)
 337 {
 338         return scnprintf(bf, size, "%#lx", arg->val);
 339 }
 340
 341 #define SCA_HEX syscall_arg__scnprintf_hex
 342
 343 static size_t syscall_arg__scnprintf_int(char *bf, size_t size,
 344                                          struct syscall_arg *arg)
 345 {
 346         return scnprintf(bf, size, "%d", arg->val);
 347 }
 348
 349 #define SCA_INT syscall_arg__scnprintf_int
 350
 351 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
 352                                                struct syscall_arg *arg)
 353 {
 354         int printed = 0, prot = arg->val;
 355
 356         if (prot == PROT_NONE)
 357                 return scnprintf(bf, size, "NONE");
 358 #define P_MMAP_PROT(n) \
 359         if (prot & PROT_##n) { \
 360                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 361                 prot &= ~PROT_##n; \
 362         }
 363
 364         P_MMAP_PROT(EXEC);
 365         P_MMAP_PROT(READ);
 366         P_MMAP_PROT(WRITE);
 367 #ifdef PROT_SEM
 368         P_MMAP_PROT(SEM);
 369 #endif
 370         P_MMAP_PROT(GROWSDOWN);
 371         P_MMAP_PROT(GROWSUP);
 372 #undef P_MMAP_PROT
 373
 374         if (prot)
 375                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
 376
 377         return printed;
 378 }
 379
 380 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
 381
 382 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
 383                                                 struct syscall_arg *arg)
 384 {
 385         int printed = 0, flags = arg->val;
 386
 387 #define P_MMAP_FLAG(n) \
 388         if (flags & MAP_##n) { \
 389                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 390                 flags &= ~MAP_##n; \
 391         }
 392
 393         P_MMAP_FLAG(SHARED);
 394         P_MMAP_FLAG(PRIVATE);
 395 #ifdef MAP_32BIT
 396         P_MMAP_FLAG(32BIT);
 397 #endif
 398         P_MMAP_FLAG(ANONYMOUS);
 399         P_MMAP_FLAG(DENYWRITE);
 400         P_MMAP_FLAG(EXECUTABLE);
 401         P_MMAP_FLAG(FILE);
 402         P_MMAP_FLAG(FIXED);
 403         P_MMAP_FLAG(GROWSDOWN);
 404 #ifdef MAP_HUGETLB
 405         P_MMAP_FLAG(HUGETLB);
 406 #endif
 407         P_MMAP_FLAG(LOCKED);
 408         P_MMAP_FLAG(NONBLOCK);
 409         P_MMAP_FLAG(NORESERVE);
 410         P_MMAP_FLAG(POPULATE);
 411         P_MMAP_FLAG(STACK);
 412 #ifdef MAP_UNINITIALIZED
 413         P_MMAP_FLAG(UNINITIALIZED);
 414 #endif
 415 #undef P_MMAP_FLAG
 416
 417         if (flags)
 418                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 419
 420         return printed;
 421 }
 422
 423 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
 424
 425 static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
 426                                                   struct syscall_arg *arg)
 427 {
 428         int printed = 0, flags = arg->val;
 429
 430 #define P_MREMAP_FLAG(n) \
 431         if (flags & MREMAP_##n) { \
 432                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 433                 flags &= ~MREMAP_##n; \
 434         }
 435
 436         P_MREMAP_FLAG(MAYMOVE);
 437 #ifdef MREMAP_FIXED
 438         P_MREMAP_FLAG(FIXED);
 439 #endif
 440 #undef P_MREMAP_FLAG
 441
 442         if (flags)
 443                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 444
 445         return printed;
 446 }
 447
 448 #define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
 449
 450 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
 451                                                       struct syscall_arg *arg)
 452 {
 453         int behavior = arg->val;
 454
 455         switch (behavior) {
 456 #define P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
 457         P_MADV_BHV(NORMAL);
 458         P_MADV_BHV(RANDOM);
 459         P_MADV_BHV(SEQUENTIAL);
 460         P_MADV_BHV(WILLNEED);
 461         P_MADV_BHV(DONTNEED);
 462         P_MADV_BHV(REMOVE);
 463         P_MADV_BHV(DONTFORK);
 464         P_MADV_BHV(DOFORK);
 465         P_MADV_BHV(HWPOISON);
 466 #ifdef MADV_SOFT_OFFLINE
 467         P_MADV_BHV(SOFT_OFFLINE);
 468 #endif
 469         P_MADV_BHV(MERGEABLE);
 470         P_MADV_BHV(UNMERGEABLE);
 471 #ifdef MADV_HUGEPAGE
 472         P_MADV_BHV(HUGEPAGE);
 473 #endif
 474 #ifdef MADV_NOHUGEPAGE
 475         P_MADV_BHV(NOHUGEPAGE);
 476 #endif
 477 #ifdef MADV_DONTDUMP
 478         P_MADV_BHV(DONTDUMP);
 479 #endif
 480 #ifdef MADV_DODUMP
 481         P_MADV_BHV(DODUMP);
 482 #endif
 483 #undef P_MADV_PHV
 484         default: break;
 485         }
 486
 487         return scnprintf(bf, size, "%#x", behavior);
 488 }
 489
 490 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
 491
 492 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
 493                                            struct syscall_arg *arg)
 494 {
 495         int printed = 0, op = arg->val;
 496
 497         if (op == 0)
 498                 return scnprintf(bf, size, "NONE");
 499 #define P_CMD(cmd) \
 500         if ((op & LOCK_##cmd) == LOCK_##cmd) { \
 501                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #cmd); \
 502                 op &= ~LOCK_##cmd; \
 503         }
 504
 505         P_CMD(SH);
 506         P_CMD(EX);
 507         P_CMD(NB);
 508         P_CMD(UN);
 509         P_CMD(MAND);
 510         P_CMD(RW);
 511         P_CMD(READ);
 512         P_CMD(WRITE);
 513 #undef P_OP
 514
 515         if (op)
 516                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", op);
 517
 518         return printed;
 519 }
 520
 521 #define SCA_FLOCK syscall_arg__scnprintf_flock
 522
 523 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
 524 {
 525         enum syscall_futex_args {
 526                 SCF_UADDR   = (1 << 0),
 527                 SCF_OP      = (1 << 1),
 528                 SCF_VAL     = (1 << 2),
 529                 SCF_TIMEOUT = (1 << 3),
 530                 SCF_UADDR2  = (1 << 4),
 531                 SCF_VAL3    = (1 << 5),
 532         };
 533         int op = arg->val;
 534         int cmd = op & FUTEX_CMD_MASK;
 535         size_t printed = 0;
 536
 537         switch (cmd) {
 538 #define P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
 539         P_FUTEX_OP(WAIT);           arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
 540         P_FUTEX_OP(WAKE);           arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 541         P_FUTEX_OP(FD);             arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 542         P_FUTEX_OP(REQUEUE);        arg->mask |= SCF_VAL3|SCF_TIMEOUT;            break;
 543         P_FUTEX_OP(CMP_REQUEUE);    arg->mask |= SCF_TIMEOUT;                     break;
 544         P_FUTEX_OP(CMP_REQUEUE_PI); arg->mask |= SCF_TIMEOUT;                     break;
 545         P_FUTEX_OP(WAKE_OP);                                                      break;
 546         P_FUTEX_OP(LOCK_PI);        arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 547         P_FUTEX_OP(UNLOCK_PI);      arg->mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 548         P_FUTEX_OP(TRYLOCK_PI);     arg->mask |= SCF_VAL3|SCF_UADDR2;             break;
 549         P_FUTEX_OP(WAIT_BITSET);    arg->mask |= SCF_UADDR2;                      break;
 550         P_FUTEX_OP(WAKE_BITSET);    arg->mask |= SCF_UADDR2;                      break;
 551         P_FUTEX_OP(WAIT_REQUEUE_PI);                                              break;
 552         default: printed = scnprintf(bf, size, "%#x", cmd);                       break;
 553         }
 554
 555         if (op & FUTEX_PRIVATE_FLAG)
 556                 printed += scnprintf(bf + printed, size - printed, "|PRIV");
 557
 558         if (op & FUTEX_CLOCK_REALTIME)
 559                 printed += scnprintf(bf + printed, size - printed, "|CLKRT");
 560
 561         return printed;
 562 }
 563
 564 #define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op
 565
 566 static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
 567 static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, 1);
 568
 569 static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
 570 static DEFINE_STRARRAY(itimers);
 571
 572 static const char *keyctl_options[] = {
 573         "GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
 574         "SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
 575         "INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
 576         "ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
 577         "INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
 578 };
 579 static DEFINE_STRARRAY(keyctl_options);
 580
 581 static const char *whences[] = { "SET", "CUR", "END",
 582 #ifdef SEEK_DATA
 583 "DATA",
 584 #endif
 585 #ifdef SEEK_HOLE
 586 "HOLE",
 587 #endif
 588 };
 589 static DEFINE_STRARRAY(whences);
 590
 591 static const char *fcntl_cmds[] = {
 592         "DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
 593         "SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "F_GETLK64",
 594         "F_SETLK64", "F_SETLKW64", "F_SETOWN_EX", "F_GETOWN_EX",
 595         "F_GETOWNER_UIDS",
 596 };
 597 static DEFINE_STRARRAY(fcntl_cmds);
 598
 599 static const char *rlimit_resources[] = {
 600         "CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
 601         "MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
 602         "RTTIME",
 603 };
 604 static DEFINE_STRARRAY(rlimit_resources);
 605
 606 static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
 607 static DEFINE_STRARRAY(sighow);
 608
 609 static const char *clockid[] = {
 610         "REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
 611         "MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
 612         "REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
 613 };
 614 static DEFINE_STRARRAY(clockid);
 615
 616 static const char *socket_families[] = {
 617         "UNSPEC", "LOCAL", "INET", "AX25", "IPX", "APPLETALK", "NETROM",
 618         "BRIDGE", "ATMPVC", "X25", "INET6", "ROSE", "DECnet", "NETBEUI",
 619         "SECURITY", "KEY", "NETLINK", "PACKET", "ASH", "ECONET", "ATMSVC",
 620         "RDS", "SNA", "IRDA", "PPPOX", "WANPIPE", "LLC", "IB", "CAN", "TIPC",
 621         "BLUETOOTH", "IUCV", "RXRPC", "ISDN", "PHONET", "IEEE802154", "CAIF",
 622         "ALG", "NFC", "VSOCK",
 623 };
 624 static DEFINE_STRARRAY(socket_families);
 625
 626 #ifndef SOCK_TYPE_MASK
 627 #define SOCK_TYPE_MASK 0xf
 628 #endif
 629
 630 static size_t syscall_arg__scnprintf_socket_type(char *bf, size_t size,
 631                                                       struct syscall_arg *arg)
 632 {
 633         size_t printed;
 634         int type = arg->val,
 635             flags = type & ~SOCK_TYPE_MASK;
 636
 637         type &= SOCK_TYPE_MASK;
 638         /*
 639          * Can't use a strarray, MIPS may override for ABI reasons.
 640          */
 641         switch (type) {
 642 #define P_SK_TYPE(n) case SOCK_##n: printed = scnprintf(bf, size, #n); break;
 643         P_SK_TYPE(STREAM);
 644         P_SK_TYPE(DGRAM);
 645         P_SK_TYPE(RAW);
 646         P_SK_TYPE(RDM);
 647         P_SK_TYPE(SEQPACKET);
 648         P_SK_TYPE(DCCP);
 649         P_SK_TYPE(PACKET);
 650 #undef P_SK_TYPE
 651         default:
 652                 printed = scnprintf(bf, size, "%#x", type);
 653         }
 654
 655 #define P_SK_FLAG(n) \
 656         if (flags & SOCK_##n) { \
 657                 printed += scnprintf(bf + printed, size - printed, "|%s", #n); \
 658                 flags &= ~SOCK_##n; \
 659         }
 660
 661         P_SK_FLAG(CLOEXEC);
 662         P_SK_FLAG(NONBLOCK);
 663 #undef P_SK_FLAG
 664
 665         if (flags)
 666                 printed += scnprintf(bf + printed, size - printed, "|%#x", flags);
 667
 668         return printed;
 669 }
 670
 671 #define SCA_SK_TYPE syscall_arg__scnprintf_socket_type
 672
 673 #ifndef MSG_PROBE
 674 #define MSG_PROBE            0x10
 675 #endif
 676 #ifndef MSG_WAITFORONE
 677 #define MSG_WAITFORONE  0x10000
 678 #endif
 679 #ifndef MSG_SENDPAGE_NOTLAST
 680 #define MSG_SENDPAGE_NOTLAST 0x20000
 681 #endif
 682 #ifndef MSG_FASTOPEN
 683 #define MSG_FASTOPEN         0x20000000
 684 #endif
 685
 686 static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
 687                                                struct syscall_arg *arg)
 688 {
 689         int printed = 0, flags = arg->val;
 690
 691         if (flags == 0)
 692                 return scnprintf(bf, size, "NONE");
 693 #define P_MSG_FLAG(n) \
 694         if (flags & MSG_##n) { \
 695                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 696                 flags &= ~MSG_##n; \
 697         }
 698
 699         P_MSG_FLAG(OOB);
 700         P_MSG_FLAG(PEEK);
 701         P_MSG_FLAG(DONTROUTE);
 702         P_MSG_FLAG(TRYHARD);
 703         P_MSG_FLAG(CTRUNC);
 704         P_MSG_FLAG(PROBE);
 705         P_MSG_FLAG(TRUNC);
 706         P_MSG_FLAG(DONTWAIT);
 707         P_MSG_FLAG(EOR);
 708         P_MSG_FLAG(WAITALL);
 709         P_MSG_FLAG(FIN);
 710         P_MSG_FLAG(SYN);
 711         P_MSG_FLAG(CONFIRM);
 712         P_MSG_FLAG(RST);
 713         P_MSG_FLAG(ERRQUEUE);
 714         P_MSG_FLAG(NOSIGNAL);
 715         P_MSG_FLAG(MORE);
 716         P_MSG_FLAG(WAITFORONE);
 717         P_MSG_FLAG(SENDPAGE_NOTLAST);
 718         P_MSG_FLAG(FASTOPEN);
 719         P_MSG_FLAG(CMSG_CLOEXEC);
 720 #undef P_MSG_FLAG
 721
 722         if (flags)
 723                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 724
 725         return printed;
 726 }
 727
 728 #define SCA_MSG_FLAGS syscall_arg__scnprintf_msg_flags
 729
 730 static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
 731                                                  struct syscall_arg *arg)
 732 {
 733         size_t printed = 0;
 734         int mode = arg->val;
 735
 736         if (mode == F_OK) /* 0 */
 737                 return scnprintf(bf, size, "F");
 738 #define P_MODE(n) \
 739         if (mode & n##_OK) { \
 740                 printed += scnprintf(bf + printed, size - printed, "%s", #n); \
 741                 mode &= ~n##_OK; \
 742         }
 743
 744         P_MODE(R);
 745         P_MODE(W);
 746         P_MODE(X);
 747 #undef P_MODE
 748
 749         if (mode)
 750                 printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
 751
 752         return printed;
 753 }
 754
 755 #define SCA_ACCMODE syscall_arg__scnprintf_access_mode
 756
 757 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
 758                                               struct syscall_arg *arg);
 759
 760 #define SCA_FILENAME syscall_arg__scnprintf_filename
 761
 762 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
 763                                                struct syscall_arg *arg)
 764 {
 765         int printed = 0, flags = arg->val;
 766
 767         if (!(flags & O_CREAT))
 768                 arg->mask |= 1 << (arg->idx + 1); /* Mask the mode parm */
 769
 770         if (flags == 0)
 771                 return scnprintf(bf, size, "RDONLY");
 772 #define P_FLAG(n) \
 773         if (flags & O_##n) { \
 774                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 775                 flags &= ~O_##n; \
 776         }
 777
 778         P_FLAG(APPEND);
 779         P_FLAG(ASYNC);
 780         P_FLAG(CLOEXEC);
 781         P_FLAG(CREAT);
 782         P_FLAG(DIRECT);
 783         P_FLAG(DIRECTORY);
 784         P_FLAG(EXCL);
 785         P_FLAG(LARGEFILE);
 786         P_FLAG(NOATIME);
 787         P_FLAG(NOCTTY);
 788 #ifdef O_NONBLOCK
 789         P_FLAG(NONBLOCK);
 790 #elif O_NDELAY
 791         P_FLAG(NDELAY);
 792 #endif
 793 #ifdef O_PATH
 794         P_FLAG(PATH);
 795 #endif
 796         P_FLAG(RDWR);
 797 #ifdef O_DSYNC
 798         if ((flags & O_SYNC) == O_SYNC)
 799                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
 800         else {
 801                 P_FLAG(DSYNC);
 802         }
 803 #else
 804         P_FLAG(SYNC);
 805 #endif
 806         P_FLAG(TRUNC);
 807         P_FLAG(WRONLY);
 808 #undef P_FLAG
 809
 810         if (flags)
 811                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 812
 813         return printed;
 814 }
 815
 816 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
 817
 818 static size_t syscall_arg__scnprintf_perf_flags(char *bf, size_t size,
 819                                                 struct syscall_arg *arg)
 820 {
 821         int printed = 0, flags = arg->val;
 822
 823         if (flags == 0)
 824                 return 0;
 825
 826 #define P_FLAG(n) \
 827         if (flags & PERF_FLAG_##n) { \
 828                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 829                 flags &= ~PERF_FLAG_##n; \
 830         }
 831
 832         P_FLAG(FD_NO_GROUP);
 833         P_FLAG(FD_OUTPUT);
 834         P_FLAG(PID_CGROUP);
 835         P_FLAG(FD_CLOEXEC);
 836 #undef P_FLAG
 837
 838         if (flags)
 839                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 840
 841         return printed;
 842 }
 843
 844 #define SCA_PERF_FLAGS syscall_arg__scnprintf_perf_flags
 845
 846 static size_t syscall_arg__scnprintf_eventfd_flags(char *bf, size_t size,
 847                                                    struct syscall_arg *arg)
 848 {
 849         int printed = 0, flags = arg->val;
 850
 851         if (flags == 0)
 852                 return scnprintf(bf, size, "NONE");
 853 #define P_FLAG(n) \
 854         if (flags & EFD_##n) { \
 855                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 856                 flags &= ~EFD_##n; \
 857         }
 858
 859         P_FLAG(SEMAPHORE);
 860         P_FLAG(CLOEXEC);
 861         P_FLAG(NONBLOCK);
 862 #undef P_FLAG
 863
 864         if (flags)
 865                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 866
 867         return printed;
 868 }
 869
 870 #define SCA_EFD_FLAGS syscall_arg__scnprintf_eventfd_flags
 871
 872 static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
 873                                                 struct syscall_arg *arg)
 874 {
 875         int printed = 0, flags = arg->val;
 876
 877 #define P_FLAG(n) \
 878         if (flags & O_##n) { \
 879                 printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 880                 flags &= ~O_##n; \
 881         }
 882
 883         P_FLAG(CLOEXEC);
 884         P_FLAG(NONBLOCK);
 885 #undef P_FLAG
 886
 887         if (flags)
 888                 printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 889
 890         return printed;
 891 }
 892
 893 #define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
 894
 895 static size_t syscall_arg__scnprintf_signum(char *bf, size_t size, struct syscall_arg *arg)
 896 {
 897         int sig = arg->val;
 898
 899         switch (sig) {
 900 #define P_SIGNUM(n) case SIG##n: return scnprintf(bf, size, #n)
 901         P_SIGNUM(HUP);
 902         P_SIGNUM(INT);
 903         P_SIGNUM(QUIT);
 904         P_SIGNUM(ILL);
 905         P_SIGNUM(TRAP);
 906         P_SIGNUM(ABRT);
 907         P_SIGNUM(BUS);
 908         P_SIGNUM(FPE);
 909         P_SIGNUM(KILL);
 910         P_SIGNUM(USR1);
 911         P_SIGNUM(SEGV);
 912         P_SIGNUM(USR2);
 913         P_SIGNUM(PIPE);
 914         P_SIGNUM(ALRM);
 915         P_SIGNUM(TERM);
 916         P_SIGNUM(CHLD);
 917         P_SIGNUM(CONT);
 918         P_SIGNUM(STOP);
 919         P_SIGNUM(TSTP);
 920         P_SIGNUM(TTIN);
 921         P_SIGNUM(TTOU);
 922         P_SIGNUM(URG);
 923         P_SIGNUM(XCPU);
 924         P_SIGNUM(XFSZ);
 925         P_SIGNUM(VTALRM);
 926         P_SIGNUM(PROF);
 927         P_SIGNUM(WINCH);
 928         P_SIGNUM(IO);
 929         P_SIGNUM(PWR);
 930         P_SIGNUM(SYS);
 931 #ifdef SIGEMT
 932         P_SIGNUM(EMT);
 933 #endif
 934 #ifdef SIGSTKFLT
 935         P_SIGNUM(STKFLT);
 936 #endif
 937 #ifdef SIGSWI
 938         P_SIGNUM(SWI);
 939 #endif
 940         default: break;
 941         }
 942
 943         return scnprintf(bf, size, "%#x", sig);
 944 }
 945
 946 #define SCA_SIGNUM syscall_arg__scnprintf_signum
 947
 948 #if defined(__i386__) || defined(__x86_64__)
 949 /*
 950  * FIXME: Make this available to all arches.
 951  */
 952 #define TCGETS          0x5401
 953
 954 static const char *tioctls[] = {
 955         "TCGETS", "TCSETS", "TCSETSW", "TCSETSF", "TCGETA", "TCSETA", "TCSETAW",
 956         "TCSETAF", "TCSBRK", "TCXONC", "TCFLSH", "TIOCEXCL", "TIOCNXCL",
 957         "TIOCSCTTY", "TIOCGPGRP", "TIOCSPGRP", "TIOCOUTQ", "TIOCSTI",
 958         "TIOCGWINSZ", "TIOCSWINSZ", "TIOCMGET", "TIOCMBIS", "TIOCMBIC",
 959         "TIOCMSET", "TIOCGSOFTCAR", "TIOCSSOFTCAR", "FIONREAD", "TIOCLINUX",
 960         "TIOCCONS", "TIOCGSERIAL", "TIOCSSERIAL", "TIOCPKT", "FIONBIO",
 961         "TIOCNOTTY", "TIOCSETD", "TIOCGETD", "TCSBRKP", [0x27] = "TIOCSBRK",
 962         "TIOCCBRK", "TIOCGSID", "TCGETS2", "TCSETS2", "TCSETSW2", "TCSETSF2",
 963         "TIOCGRS485", "TIOCSRS485", "TIOCGPTN", "TIOCSPTLCK",
 964         "TIOCGDEV||TCGETX", "TCSETX", "TCSETXF", "TCSETXW", "TIOCSIG",
 965         "TIOCVHANGUP", "TIOCGPKT", "TIOCGPTLCK", "TIOCGEXCL",
 966         [0x50] = "FIONCLEX", "FIOCLEX", "FIOASYNC", "TIOCSERCONFIG",
 967         "TIOCSERGWILD", "TIOCSERSWILD", "TIOCGLCKTRMIOS", "TIOCSLCKTRMIOS",
 968         "TIOCSERGSTRUCT", "TIOCSERGETLSR", "TIOCSERGETMULTI", "TIOCSERSETMULTI",
 969         "TIOCMIWAIT", "TIOCGICOUNT", [0x60] = "FIOQSIZE",
 970 };
 971
 972 static DEFINE_STRARRAY_OFFSET(tioctls, 0x5401);
 973 #endif /* defined(__i386__) || defined(__x86_64__) */
 974
 975 #define STRARRAY(arg, name, array) \
 976           .arg_scnprintf = { [arg] = SCA_STRARRAY, }, \
 977           .arg_parm      = { [arg] = &strarray__##array, }
 978
 979 static struct syscall_fmt {
 980         const char *name;
 981         const char *alias;
 982         size_t     (*arg_scnprintf[6])(char *bf, size_t size, struct syscall_arg *arg);
 983         void       *arg_parm[6];
 984         bool       errmsg;
 985         bool       timeout;
 986         bool       hexret;
 987 } syscall_fmts[] = {
 988         { .name     = "access",     .errmsg = true,
 989           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */
 990                              [1] = SCA_ACCMODE,  /* mode */ }, },
 991         { .name     = "arch_prctl", .errmsg = true, .alias = "prctl", },
 992         { .name     = "brk",        .hexret = true,
 993           .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
 994         { .name     = "chdir",      .errmsg = true,
 995           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
 996         { .name     = "chmod",      .errmsg = true,
 997           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
 998         { .name     = "chroot",     .errmsg = true,
 999           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1000         { .name     = "clock_gettime",  .errmsg = true, STRARRAY(0, clk_id, clockid), },
1001         { .name     = "close",      .errmsg = true,
1002           .arg_scnprintf = { [0] = SCA_CLOSE_FD, /* fd */ }, },
1003         { .name     = "connect",    .errmsg = true, },
1004         { .name     = "creat",      .errmsg = true,
1005           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1006         { .name     = "dup",        .errmsg = true,
1007           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1008         { .name     = "dup2",       .errmsg = true,
1009           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1010         { .name     = "dup3",       .errmsg = true,
1011           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1012         { .name     = "epoll_ctl",  .errmsg = true, STRARRAY(1, op, epoll_ctl_ops), },
1013         { .name     = "eventfd2",   .errmsg = true,
1014           .arg_scnprintf = { [1] = SCA_EFD_FLAGS, /* flags */ }, },
1015         { .name     = "faccessat",  .errmsg = true,
1016           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1017                              [1] = SCA_FILENAME, /* filename */ }, },
1018         { .name     = "fadvise64",  .errmsg = true,
1019           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1020         { .name     = "fallocate",  .errmsg = true,
1021           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1022         { .name     = "fchdir",     .errmsg = true,
1023           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1024         { .name     = "fchmod",     .errmsg = true,
1025           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1026         { .name     = "fchmodat",   .errmsg = true,
1027           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1028                              [1] = SCA_FILENAME, /* filename */ }, },
1029         { .name     = "fchown",     .errmsg = true,
1030           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1031         { .name     = "fchownat",   .errmsg = true,
1032           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1033                              [1] = SCA_FILENAME, /* filename */ }, },
1034         { .name     = "fcntl",      .errmsg = true,
1035           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1036                              [1] = SCA_STRARRAY, /* cmd */ },
1037           .arg_parm      = { [1] = &strarray__fcntl_cmds, /* cmd */ }, },
1038         { .name     = "fdatasync",  .errmsg = true,
1039           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1040         { .name     = "flock",      .errmsg = true,
1041           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1042                              [1] = SCA_FLOCK, /* cmd */ }, },
1043         { .name     = "fsetxattr",  .errmsg = true,
1044           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1045         { .name     = "fstat",      .errmsg = true, .alias = "newfstat",
1046           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1047         { .name     = "fstatat",    .errmsg = true, .alias = "newfstatat",
1048           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1049                              [1] = SCA_FILENAME, /* filename */ }, },
1050         { .name     = "fstatfs",    .errmsg = true,
1051           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1052         { .name     = "fsync",    .errmsg = true,
1053           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1054         { .name     = "ftruncate", .errmsg = true,
1055           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1056         { .name     = "futex",      .errmsg = true,
1057           .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
1058         { .name     = "futimesat", .errmsg = true,
1059           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1060                              [1] = SCA_FILENAME, /* filename */ }, },
1061         { .name     = "getdents",   .errmsg = true,
1062           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1063         { .name     = "getdents64", .errmsg = true,
1064           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1065         { .name     = "getitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
1066         { .name     = "getrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1067         { .name     = "getxattr",    .errmsg = true,
1068           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1069         { .name     = "inotify_add_watch",          .errmsg = true,
1070           .arg_scnprintf = { [1] = SCA_FILENAME, /* pathname */ }, },
1071         { .name     = "ioctl",      .errmsg = true,
1072           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1073 #if defined(__i386__) || defined(__x86_64__)
1074 /*
1075  * FIXME: Make this available to all arches.
1076  */
1077                              [1] = SCA_STRHEXARRAY, /* cmd */
1078                              [2] = SCA_HEX, /* arg */ },
1079           .arg_parm      = { [1] = &strarray__tioctls, /* cmd */ }, },
1080 #else
1081                              [2] = SCA_HEX, /* arg */ }, },
1082 #endif
1083         { .name     = "keyctl",     .errmsg = true, STRARRAY(0, option, keyctl_options), },
1084         { .name     = "kill",       .errmsg = true,
1085           .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1086         { .name     = "lchown",    .errmsg = true,
1087           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1088         { .name     = "lgetxattr",  .errmsg = true,
1089           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1090         { .name     = "linkat",     .errmsg = true,
1091           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */ }, },
1092         { .name     = "listxattr",  .errmsg = true,
1093           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1094         { .name     = "llistxattr", .errmsg = true,
1095           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1096         { .name     = "lremovexattr",  .errmsg = true,
1097           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1098         { .name     = "lseek",      .errmsg = true,
1099           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1100                              [2] = SCA_STRARRAY, /* whence */ },
1101           .arg_parm      = { [2] = &strarray__whences, /* whence */ }, },
1102         { .name     = "lsetxattr",  .errmsg = true,
1103           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1104         { .name     = "lstat",      .errmsg = true, .alias = "newlstat",
1105           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1106         { .name     = "lsxattr",    .errmsg = true,
1107           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1108         { .name     = "madvise",    .errmsg = true,
1109           .arg_scnprintf = { [0] = SCA_HEX,      /* start */
1110                              [2] = SCA_MADV_BHV, /* behavior */ }, },
1111         { .name     = "mkdir",    .errmsg = true,
1112           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1113         { .name     = "mkdirat",    .errmsg = true,
1114           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1115                              [1] = SCA_FILENAME, /* pathname */ }, },
1116         { .name     = "mknod",      .errmsg = true,
1117           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1118         { .name     = "mknodat",    .errmsg = true,
1119           .arg_scnprintf = { [0] = SCA_FDAT, /* fd */
1120                              [1] = SCA_FILENAME, /* filename */ }, },
1121         { .name     = "mlock",      .errmsg = true,
1122           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1123         { .name     = "mlockall",   .errmsg = true,
1124           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1125         { .name     = "mmap",       .hexret = true,
1126           .arg_scnprintf = { [0] = SCA_HEX,       /* addr */
1127                              [2] = SCA_MMAP_PROT, /* prot */
1128                              [3] = SCA_MMAP_FLAGS, /* flags */
1129                              [4] = SCA_FD,        /* fd */ }, },
1130         { .name     = "mprotect",   .errmsg = true,
1131           .arg_scnprintf = { [0] = SCA_HEX, /* start */
1132                              [2] = SCA_MMAP_PROT, /* prot */ }, },
1133         { .name     = "mq_unlink", .errmsg = true,
1134           .arg_scnprintf = { [0] = SCA_FILENAME, /* u_name */ }, },
1135         { .name     = "mremap",     .hexret = true,
1136           .arg_scnprintf = { [0] = SCA_HEX, /* addr */
1137                              [3] = SCA_MREMAP_FLAGS, /* flags */
1138                              [4] = SCA_HEX, /* new_addr */ }, },
1139         { .name     = "munlock",    .errmsg = true,
1140           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1141         { .name     = "munmap",     .errmsg = true,
1142           .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
1143         { .name     = "name_to_handle_at", .errmsg = true,
1144           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1145         { .name     = "newfstatat", .errmsg = true,
1146           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1147                              [1] = SCA_FILENAME, /* filename */ }, },
1148         { .name     = "open",       .errmsg = true,
1149           .arg_scnprintf = { [0] = SCA_FILENAME,   /* filename */
1150                              [1] = SCA_OPEN_FLAGS, /* flags */ }, },
1151         { .name     = "open_by_handle_at", .errmsg = true,
1152           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1153                              [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1154         { .name     = "openat",     .errmsg = true,
1155           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1156                              [1] = SCA_FILENAME, /* filename */
1157                              [2] = SCA_OPEN_FLAGS, /* flags */ }, },
1158         { .name     = "perf_event_open", .errmsg = true,
1159           .arg_scnprintf = { [1] = SCA_INT, /* pid */
1160                              [2] = SCA_INT, /* cpu */
1161                              [3] = SCA_FD,  /* group_fd */
1162                              [4] = SCA_PERF_FLAGS,  /* flags */ }, },
1163         { .name     = "pipe2",      .errmsg = true,
1164           .arg_scnprintf = { [1] = SCA_PIPE_FLAGS, /* flags */ }, },
1165         { .name     = "poll",       .errmsg = true, .timeout = true, },
1166         { .name     = "ppoll",      .errmsg = true, .timeout = true, },
1167         { .name     = "pread",      .errmsg = true, .alias = "pread64",
1168           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1169         { .name     = "preadv",     .errmsg = true, .alias = "pread",
1170           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1171         { .name     = "prlimit64",  .errmsg = true, STRARRAY(1, resource, rlimit_resources), },
1172         { .name     = "pwrite",     .errmsg = true, .alias = "pwrite64",
1173           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1174         { .name     = "pwritev",    .errmsg = true,
1175           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1176         { .name     = "read",       .errmsg = true,
1177           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1178         { .name     = "readlink",   .errmsg = true,
1179           .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
1180         { .name     = "readlinkat", .errmsg = true,
1181           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1182                              [1] = SCA_FILENAME, /* pathname */ }, },
1183         { .name     = "readv",      .errmsg = true,
1184           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1185         { .name     = "recvfrom",   .errmsg = true,
1186           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1187                              [3] = SCA_MSG_FLAGS, /* flags */ }, },
1188         { .name     = "recvmmsg",   .errmsg = true,
1189           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1190                              [3] = SCA_MSG_FLAGS, /* flags */ }, },
1191         { .name     = "recvmsg",    .errmsg = true,
1192           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1193                              [2] = SCA_MSG_FLAGS, /* flags */ }, },
1194         { .name     = "removexattr", .errmsg = true,
1195           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1196         { .name     = "renameat",   .errmsg = true,
1197           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1198         { .name     = "rmdir",    .errmsg = true,
1199           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1200         { .name     = "rt_sigaction", .errmsg = true,
1201           .arg_scnprintf = { [0] = SCA_SIGNUM, /* sig */ }, },
1202         { .name     = "rt_sigprocmask",  .errmsg = true, STRARRAY(0, how, sighow), },
1203         { .name     = "rt_sigqueueinfo", .errmsg = true,
1204           .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1205         { .name     = "rt_tgsigqueueinfo", .errmsg = true,
1206           .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1207         { .name     = "select",     .errmsg = true, .timeout = true, },
1208         { .name     = "sendmmsg",    .errmsg = true,
1209           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1210                              [3] = SCA_MSG_FLAGS, /* flags */ }, },
1211         { .name     = "sendmsg",    .errmsg = true,
1212           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1213                              [2] = SCA_MSG_FLAGS, /* flags */ }, },
1214         { .name     = "sendto",     .errmsg = true,
1215           .arg_scnprintf = { [0] = SCA_FD, /* fd */
1216                              [3] = SCA_MSG_FLAGS, /* flags */ }, },
1217         { .name     = "setitimer",  .errmsg = true, STRARRAY(0, which, itimers), },
1218         { .name     = "setrlimit",  .errmsg = true, STRARRAY(0, resource, rlimit_resources), },
1219         { .name     = "setxattr",   .errmsg = true,
1220           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1221         { .name     = "shutdown",   .errmsg = true,
1222           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1223         { .name     = "socket",     .errmsg = true,
1224           .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1225                              [1] = SCA_SK_TYPE, /* type */ },
1226           .arg_parm      = { [0] = &strarray__socket_families, /* family */ }, },
1227         { .name     = "socketpair", .errmsg = true,
1228           .arg_scnprintf = { [0] = SCA_STRARRAY, /* family */
1229                              [1] = SCA_SK_TYPE, /* type */ },
1230           .arg_parm      = { [0] = &strarray__socket_families, /* family */ }, },
1231         { .name     = "stat",       .errmsg = true, .alias = "newstat",
1232           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1233         { .name     = "statfs",     .errmsg = true,
1234           .arg_scnprintf = { [0] = SCA_FILENAME, /* pathname */ }, },
1235         { .name     = "swapoff",    .errmsg = true,
1236           .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
1237         { .name     = "swapon",     .errmsg = true,
1238           .arg_scnprintf = { [0] = SCA_FILENAME, /* specialfile */ }, },
1239         { .name     = "symlinkat",  .errmsg = true,
1240           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */ }, },
1241         { .name     = "tgkill",     .errmsg = true,
1242           .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
1243         { .name     = "tkill",      .errmsg = true,
1244           .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
1245         { .name     = "truncate",   .errmsg = true,
1246           .arg_scnprintf = { [0] = SCA_FILENAME, /* path */ }, },
1247         { .name     = "uname",      .errmsg = true, .alias = "newuname", },
1248         { .name     = "unlinkat",   .errmsg = true,
1249           .arg_scnprintf = { [0] = SCA_FDAT, /* dfd */
1250                              [1] = SCA_FILENAME, /* pathname */ }, },
1251         { .name     = "utime",  .errmsg = true,
1252           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1253         { .name     = "utimensat",  .errmsg = true,
1254           .arg_scnprintf = { [0] = SCA_FDAT, /* dirfd */
1255                              [1] = SCA_FILENAME, /* filename */ }, },
1256         { .name     = "utimes",  .errmsg = true,
1257           .arg_scnprintf = { [0] = SCA_FILENAME, /* filename */ }, },
1258         { .name     = "vmsplice",  .errmsg = true,
1259           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1260         { .name     = "write",      .errmsg = true,
1261           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1262         { .name     = "writev",     .errmsg = true,
1263           .arg_scnprintf = { [0] = SCA_FD, /* fd */ }, },
1264 };
1265
1266 static int syscall_fmt__cmp(const void *name, const void *fmtp)
1267 {
1268         const struct syscall_fmt *fmt = fmtp;
1269         return strcmp(name, fmt->name);
1270 }
1271
1272 static struct syscall_fmt *syscall_fmt__find(const char *name)
1273 {
1274         const int nmemb = ARRAY_SIZE(syscall_fmts);
1275         return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1276 }
1277
1278 struct syscall {
1279         struct event_format *tp_format;
1280         int                 nr_args;
1281         struct format_field *args;
1282         const char          *name;
1283         bool                is_exit;
1284         struct syscall_fmt  *fmt;
1285         size_t              (**arg_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1286         void                **arg_parm;
1287 };
1288
1289 static size_t fprintf_duration(unsigned long t, FILE *fp)
1290 {
1291         double duration = (double)t / NSEC_PER_MSEC;
1292         size_t printed = fprintf(fp, "(");
1293
1294         if (duration >= 1.0)
1295                 printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1296         else if (duration >= 0.01)
1297                 printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1298         else
1299                 printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1300         return printed + fprintf(fp, "): ");
1301 }
1302
1303 /**
1304  * filename.ptr: The filename char pointer that will be vfs_getname'd
1305  * filename.entry_str_pos: Where to insert the string translated from
1306  *                         filename.ptr by the vfs_getname tracepoint/kprobe.
1307  */
1308 struct thread_trace {
1309         u64               entry_time;
1310         u64               exit_time;
1311         bool              entry_pending;
1312         unsigned long     nr_events;
1313         unsigned long     pfmaj, pfmin;
1314         char              *entry_str;
1315         double            runtime_ms;
1316         struct {
1317                 unsigned long ptr;
1318                 int           entry_str_pos;
1319         } filename;
1320         struct {
1321                 int       max;
1322                 char      **table;
1323         } paths;
1324
1325         struct intlist *syscall_stats;
1326 };
1327
1328 static struct thread_trace *thread_trace__new(void)
1329 {
1330         struct thread_trace *ttrace =  zalloc(sizeof(struct thread_trace));
1331
1332         if (ttrace)
1333                 ttrace->paths.max = -1;
1334
1335         ttrace->syscall_stats = intlist__new(NULL);
1336
1337         return ttrace;
1338 }
1339
1340 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
1341 {
1342         struct thread_trace *ttrace;
1343
1344         if (thread == NULL)
1345                 goto fail;
1346
1347         if (thread__priv(thread) == NULL)
1348                 thread__set_priv(thread, thread_trace__new());
1349
1350         if (thread__priv(thread) == NULL)
1351                 goto fail;
1352
1353         ttrace = thread__priv(thread);
1354         ++ttrace->nr_events;
1355
1356         return ttrace;
1357 fail:
1358         color_fprintf(fp, PERF_COLOR_RED,
1359                       "WARNING: not enough memory, dropping samples!\n");
1360         return NULL;
1361 }
1362
1363 #define TRACE_PFMAJ             (1 << 0)
1364 #define TRACE_PFMIN             (1 << 1)
1365
1366 static const size_t trace__entry_str_size = 2048;
1367
1368 struct trace {
1369         struct perf_tool        tool;
1370         struct {
1371                 int             machine;
1372                 int             open_id;
1373         }                       audit;
1374         struct {
1375                 int             max;
1376                 struct syscall  *table;
1377                 struct {
1378                         struct perf_evsel *sys_enter,
1379                                           *sys_exit;
1380                 }               events;
1381         } syscalls;
1382         struct record_opts      opts;
1383         struct perf_evlist      *evlist;
1384         struct machine          *host;
1385         struct thread           *current;
1386         u64                     base_time;
1387         FILE                    *output;
1388         unsigned long           nr_events;
1389         struct strlist          *ev_qualifier;
1390         struct {
1391                 size_t          nr;
1392                 int             *entries;
1393         }                       ev_qualifier_ids;
1394         const char              *last_vfs_getname;
1395         struct intlist          *tid_list;
1396         struct intlist          *pid_list;
1397         struct {
1398                 size_t          nr;
1399                 pid_t           *entries;
1400         }                       filter_pids;
1401         double                  duration_filter;
1402         double                  runtime_ms;
1403         struct {
1404                 u64             vfs_getname,
1405                                 proc_getname;
1406         } stats;
1407         bool                    not_ev_qualifier;
1408         bool                    live;
1409         bool                    full_time;
1410         bool                    sched;
1411         bool                    multiple_threads;
1412         bool                    summary;
1413         bool                    summary_only;
1414         bool                    show_comm;
1415         bool                    show_tool_stats;
1416         bool                    trace_syscalls;
1417         bool                    force;
1418         bool                    vfs_getname;
1419         int                     trace_pgfaults;
1420 };
1421
1422 static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1423 {
1424         struct thread_trace *ttrace = thread__priv(thread);
1425
1426         if (fd > ttrace->paths.max) {
1427                 char **npath = realloc(ttrace->paths.table, (fd + 1) * sizeof(char *));
1428
1429                 if (npath == NULL)
1430                         return -1;
1431
1432                 if (ttrace->paths.max != -1) {
1433                         memset(npath + ttrace->paths.max + 1, 0,
1434                                (fd - ttrace->paths.max) * sizeof(char *));
1435                 } else {
1436                         memset(npath, 0, (fd + 1) * sizeof(char *));
1437                 }
1438
1439                 ttrace->paths.table = npath;
1440                 ttrace->paths.max   = fd;
1441         }
1442
1443         ttrace->paths.table[fd] = strdup(pathname);
1444
1445         return ttrace->paths.table[fd] != NULL ? 0 : -1;
1446 }
1447
1448 static int thread__read_fd_path(struct thread *thread, int fd)
1449 {
1450         char linkname[PATH_MAX], pathname[PATH_MAX];
1451         struct stat st;
1452         int ret;
1453
1454         if (thread->pid_ == thread->tid) {
1455                 scnprintf(linkname, sizeof(linkname),
1456                           "/proc/%d/fd/%d", thread->pid_, fd);
1457         } else {
1458                 scnprintf(linkname, sizeof(linkname),
1459                           "/proc/%d/task/%d/fd/%d", thread->pid_, thread->tid, fd);
1460         }
1461
1462         if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1463                 return -1;
1464
1465         ret = readlink(linkname, pathname, sizeof(pathname));
1466
1467         if (ret < 0 || ret > st.st_size)
1468                 return -1;
1469
1470         pathname[ret] = '\0';
1471         return trace__set_fd_pathname(thread, fd, pathname);
1472 }
1473
1474 static const char *thread__fd_path(struct thread *thread, int fd,
1475                                    struct trace *trace)
1476 {
1477         struct thread_trace *ttrace = thread__priv(thread);
1478
1479         if (ttrace == NULL)
1480                 return NULL;
1481
1482         if (fd < 0)
1483                 return NULL;
1484
1485         if ((fd > ttrace->paths.max || ttrace->paths.table[fd] == NULL)) {
1486                 if (!trace->live)
1487                         return NULL;
1488                 ++trace->stats.proc_getname;
1489                 if (thread__read_fd_path(thread, fd))
1490                         return NULL;
1491         }
1492
1493         return ttrace->paths.table[fd];
1494 }
1495
1496 static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
1497                                         struct syscall_arg *arg)
1498 {
1499         int fd = arg->val;
1500         size_t printed = scnprintf(bf, size, "%d", fd);
1501         const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1502
1503         if (path)
1504                 printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1505
1506         return printed;
1507 }
1508
1509 static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1510                                               struct syscall_arg *arg)
1511 {
1512         int fd = arg->val;
1513         size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1514         struct thread_trace *ttrace = thread__priv(arg->thread);
1515
1516         if (ttrace && fd >= 0 && fd <= ttrace->paths.max)
1517                 zfree(&ttrace->paths.table[fd]);
1518
1519         return printed;
1520 }
1521
1522 static void thread__set_filename_pos(struct thread *thread, const char *bf,
1523                                      unsigned long ptr)
1524 {
1525         struct thread_trace *ttrace = thread__priv(thread);
1526
1527         ttrace->filename.ptr = ptr;
1528         ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1529 }
1530
1531 static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1532                                               struct syscall_arg *arg)
1533 {
1534         unsigned long ptr = arg->val;
1535
1536         if (!arg->trace->vfs_getname)
1537                 return scnprintf(bf, size, "%#x", ptr);
1538
1539         thread__set_filename_pos(arg->thread, bf, ptr);
1540         return 0;
1541 }
1542
1543 static bool trace__filter_duration(struct trace *trace, double t)
1544 {
1545         return t < (trace->duration_filter * NSEC_PER_MSEC);
1546 }
1547
1548 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1549 {
1550         double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1551
1552         return fprintf(fp, "%10.3f ", ts);
1553 }
1554
1555 static bool done = false;
1556 static bool interrupted = false;
1557
1558 static void sig_handler(int sig)
1559 {
1560         done = true;
1561         interrupted = sig == SIGINT;
1562 }
1563
1564 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1565                                         u64 duration, u64 tstamp, FILE *fp)
1566 {
1567         size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
1568         printed += fprintf_duration(duration, fp);
1569
1570         if (trace->multiple_threads) {
1571                 if (trace->show_comm)
1572                         printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1573                 printed += fprintf(fp, "%d ", thread->tid);
1574         }
1575
1576         return printed;
1577 }
1578
1579 static int trace__process_event(struct trace *trace, struct machine *machine,
1580                                 union perf_event *event, struct perf_sample *sample)
1581 {
1582         int ret = 0;
1583
1584         switch (event->header.type) {
1585         case PERF_RECORD_LOST:
1586                 color_fprintf(trace->output, PERF_COLOR_RED,
1587                               "LOST %" PRIu64 " events!\n", event->lost.lost);
1588                 ret = machine__process_lost_event(machine, event, sample);
1589         default:
1590                 ret = machine__process_event(machine, event, sample);
1591                 break;
1592         }
1593
1594         return ret;
1595 }
1596
1597 static int trace__tool_process(struct perf_tool *tool,
1598                                union perf_event *event,
1599                                struct perf_sample *sample,
1600                                struct machine *machine)
1601 {
1602         struct trace *trace = container_of(tool, struct trace, tool);
1603         return trace__process_event(trace, machine, event, sample);
1604 }
1605
1606 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
1607 {
1608         int err = symbol__init(NULL);
1609
1610         if (err)
1611                 return err;
1612
1613         trace->host = machine__new_host();
1614         if (trace->host == NULL)
1615                 return -ENOMEM;
1616
1617         if (trace_event__register_resolver(trace->host, machine__resolve_kernel_addr) < 0)
1618                 return -errno;
1619
1620         err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
1621                                             evlist->threads, trace__tool_process, false,
1622                                             trace->opts.proc_map_timeout);
1623         if (err)
1624                 symbol__exit();
1625
1626         return err;
1627 }
1628
1629 static int syscall__set_arg_fmts(struct syscall *sc)
1630 {
1631         struct format_field *field;
1632         int idx = 0;
1633
1634         sc->arg_scnprintf = calloc(sc->nr_args, sizeof(void *));
1635         if (sc->arg_scnprintf == NULL)
1636                 return -1;
1637
1638         if (sc->fmt)
1639                 sc->arg_parm = sc->fmt->arg_parm;
1640
1641         for (field = sc->args; field; field = field->next) {
1642                 if (sc->fmt && sc->fmt->arg_scnprintf[idx])
1643                         sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
1644                 else if (field->flags & FIELD_IS_POINTER)
1645                         sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
1646                 ++idx;
1647         }
1648
1649         return 0;
1650 }
1651
1652 static int trace__read_syscall_info(struct trace *trace, int id)
1653 {
1654         char tp_name[128];
1655         struct syscall *sc;
1656         const char *name = audit_syscall_to_name(id, trace->audit.machine);
1657
1658         if (name == NULL)
1659                 return -1;
1660
1661         if (id > trace->syscalls.max) {
1662                 struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
1663
1664                 if (nsyscalls == NULL)
1665                         return -1;
1666
1667                 if (trace->syscalls.max != -1) {
1668                         memset(nsyscalls + trace->syscalls.max + 1, 0,
1669                                (id - trace->syscalls.max) * sizeof(*sc));
1670                 } else {
1671                         memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
1672                 }
1673
1674                 trace->syscalls.table = nsyscalls;
1675                 trace->syscalls.max   = id;
1676         }
1677
1678         sc = trace->syscalls.table + id;
1679         sc->name = name;
1680
1681         sc->fmt  = syscall_fmt__find(sc->name);
1682
1683         snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
1684         sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1685
1686         if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
1687                 snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
1688                 sc->tp_format = trace_event__tp_format("syscalls", tp_name);
1689         }
1690
1691         if (sc->tp_format == NULL)
1692                 return -1;
1693
1694         sc->args = sc->tp_format->format.fields;
1695         sc->nr_args = sc->tp_format->format.nr_fields;
1696         /* drop nr field - not relevant here; does not exist on older kernels */
1697         if (sc->args && strcmp(sc->args->name, "nr") == 0) {
1698                 sc->args = sc->args->next;
1699                 --sc->nr_args;
1700         }
1701
1702         sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
1703
1704         return syscall__set_arg_fmts(sc);
1705 }
1706
1707 static int trace__validate_ev_qualifier(struct trace *trace)
1708 {
1709         int err = 0, i;
1710         struct str_node *pos;
1711
1712         trace->ev_qualifier_ids.nr = strlist__nr_entries(trace->ev_qualifier);
1713         trace->ev_qualifier_ids.entries = malloc(trace->ev_qualifier_ids.nr *
1714                                                  sizeof(trace->ev_qualifier_ids.entries[0]));
1715
1716         if (trace->ev_qualifier_ids.entries == NULL) {
1717                 fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
1718                        trace->output);
1719                 err = -EINVAL;
1720                 goto out;
1721         }
1722
1723         i = 0;
1724
1725         strlist__for_each(pos, trace->ev_qualifier) {
1726                 const char *sc = pos->s;
1727                 int id = audit_name_to_syscall(sc, trace->audit.machine);
1728
1729                 if (id < 0) {
1730                         if (err == 0) {
1731                                 fputs("Error:\tInvalid syscall ", trace->output);
1732                                 err = -EINVAL;
1733                         } else {
1734                                 fputs(", ", trace->output);
1735                         }
1736
1737                         fputs(sc, trace->output);
1738                 }
1739
1740                 trace->ev_qualifier_ids.entries[i++] = id;
1741         }
1742
1743         if (err < 0) {
1744                 fputs("\nHint:\ttry 'perf list syscalls:sys_enter_*'"
1745                       "\nHint:\tand: 'man syscalls'\n", trace->output);
1746                 zfree(&trace->ev_qualifier_ids.entries);
1747                 trace->ev_qualifier_ids.nr = 0;
1748         }
1749 out:
1750         return err;
1751 }
1752
1753 /*
1754  * args is to be interpreted as a series of longs but we need to handle
1755  * 8-byte unaligned accesses. args points to raw_data within the event
1756  * and raw_data is guaranteed to be 8-byte unaligned because it is
1757  * preceded by raw_size which is a u32. So we need to copy args to a temp
1758  * variable to read it. Most notably this avoids extended load instructions
1759  * on unaligned addresses
1760  */
1761
1762 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
1763                                       unsigned char *args, struct trace *trace,
1764                                       struct thread *thread)
1765 {
1766         size_t printed = 0;
1767         unsigned char *p;
1768         unsigned long val;
1769
1770         if (sc->args != NULL) {
1771                 struct format_field *field;
1772                 u8 bit = 1;
1773                 struct syscall_arg arg = {
1774                         .idx    = 0,
1775                         .mask   = 0,
1776                         .trace  = trace,
1777                         .thread = thread,
1778                 };
1779
1780                 for (field = sc->args; field;
1781                      field = field->next, ++arg.idx, bit <<= 1) {
1782                         if (arg.mask & bit)
1783                                 continue;
1784
1785                         /* special care for unaligned accesses */
1786                         p = args + sizeof(unsigned long) * arg.idx;
1787                         memcpy(&val, p, sizeof(val));
1788
1789                         /*
1790                          * Suppress this argument if its value is zero and
1791                          * and we don't have a string associated in an
1792                          * strarray for it.
1793                          */
1794                         if (val == 0 &&
1795                             !(sc->arg_scnprintf &&
1796                               sc->arg_scnprintf[arg.idx] == SCA_STRARRAY &&
1797                               sc->arg_parm[arg.idx]))
1798                                 continue;
1799
1800                         printed += scnprintf(bf + printed, size - printed,
1801                                              "%s%s: ", printed ? ", " : "", field->name);
1802                         if (sc->arg_scnprintf && sc->arg_scnprintf[arg.idx]) {
1803                                 arg.val = val;
1804                                 if (sc->arg_parm)
1805                                         arg.parm = sc->arg_parm[arg.idx];
1806                                 printed += sc->arg_scnprintf[arg.idx](bf + printed,
1807                                                                       size - printed, &arg);
1808                         } else {
1809                                 printed += scnprintf(bf + printed, size - printed,
1810                                                      "%ld", val);
1811                         }
1812                 }
1813         } else {
1814                 int i = 0;
1815
1816                 while (i < 6) {
1817                         /* special care for unaligned accesses */
1818                         p = args + sizeof(unsigned long) * i;
1819                         memcpy(&val, p, sizeof(val));
1820                         printed += scnprintf(bf + printed, size - printed,
1821                                              "%sarg%d: %ld",
1822                                              printed ? ", " : "", i, val);
1823                         ++i;
1824                 }
1825         }
1826
1827         return printed;
1828 }
1829
1830 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
1831                                   union perf_event *event,
1832                                   struct perf_sample *sample);
1833
1834 static struct syscall *trace__syscall_info(struct trace *trace,
1835                                            struct perf_evsel *evsel, int id)
1836 {
1837
1838         if (id < 0) {
1839
1840                 /*
1841                  * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
1842                  * before that, leaving at a higher verbosity level till that is
1843                  * explained. Reproduced with plain ftrace with:
1844                  *
1845                  * echo 1 > /t/events/raw_syscalls/sys_exit/enable
1846                  * grep "NR -1 " /t/trace_pipe
1847                  *
1848                  * After generating some load on the machine.
1849                  */
1850                 if (verbose > 1) {
1851                         static u64 n;
1852                         fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
1853                                 id, perf_evsel__name(evsel), ++n);
1854                 }
1855                 return NULL;
1856         }
1857
1858         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
1859             trace__read_syscall_info(trace, id))
1860                 goto out_cant_read;
1861
1862         if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
1863                 goto out_cant_read;
1864
1865         return &trace->syscalls.table[id];
1866
1867 out_cant_read:
1868         if (verbose) {
1869                 fprintf(trace->output, "Problems reading syscall %d", id);
1870                 if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
1871                         fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
1872                 fputs(" information\n", trace->output);
1873         }
1874         return NULL;
1875 }
1876
1877 static void thread__update_stats(struct thread_trace *ttrace,
1878                                  int id, struct perf_sample *sample)
1879 {
1880         struct int_node *inode;
1881         struct stats *stats;
1882         u64 duration = 0;
1883
1884         inode = intlist__findnew(ttrace->syscall_stats, id);
1885         if (inode == NULL)
1886                 return;
1887
1888         stats = inode->priv;
1889         if (stats == NULL) {
1890                 stats = malloc(sizeof(struct stats));
1891                 if (stats == NULL)
1892                         return;
1893                 init_stats(stats);
1894                 inode->priv = stats;
1895         }
1896
1897         if (ttrace->entry_time && sample->time > ttrace->entry_time)
1898                 duration = sample->time - ttrace->entry_time;
1899
1900         update_stats(stats, duration);
1901 }
1902
1903 static int trace__printf_interrupted_entry(struct trace *trace, struct perf_sample *sample)
1904 {
1905         struct thread_trace *ttrace;
1906         u64 duration;
1907         size_t printed;
1908
1909         if (trace->current == NULL)
1910                 return 0;
1911
1912         ttrace = thread__priv(trace->current);
1913
1914         if (!ttrace->entry_pending)
1915                 return 0;
1916
1917         duration = sample->time - ttrace->entry_time;
1918
1919         printed  = trace__fprintf_entry_head(trace, trace->current, duration, sample->time, trace->output);
1920         printed += fprintf(trace->output, "%-70s) ...\n", ttrace->entry_str);
1921         ttrace->entry_pending = false;
1922
1923         return printed;
1924 }
1925
1926 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
1927                             union perf_event *event __maybe_unused,
1928                             struct perf_sample *sample)
1929 {
1930         char *msg;
1931         void *args;
1932         size_t printed = 0;
1933         struct thread *thread;
1934         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1935         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1936         struct thread_trace *ttrace;
1937
1938         if (sc == NULL)
1939                 return -1;
1940
1941         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1942         ttrace = thread__trace(thread, trace->output);
1943         if (ttrace == NULL)
1944                 goto out_put;
1945
1946         args = perf_evsel__sc_tp_ptr(evsel, args, sample);
1947
1948         if (ttrace->entry_str == NULL) {
1949                 ttrace->entry_str = malloc(trace__entry_str_size);
1950                 if (!ttrace->entry_str)
1951                         goto out_put;
1952         }
1953
1954         if (!trace->summary_only)
1955                 trace__printf_interrupted_entry(trace, sample);
1956
1957         ttrace->entry_time = sample->time;
1958         msg = ttrace->entry_str;
1959         printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
1960
1961         printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
1962                                            args, trace, thread);
1963
1964         if (sc->is_exit) {
1965                 if (!trace->duration_filter && !trace->summary_only) {
1966                         trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
1967                         fprintf(trace->output, "%-70s\n", ttrace->entry_str);
1968                 }
1969         } else
1970                 ttrace->entry_pending = true;
1971
1972         if (trace->current != thread) {
1973                 thread__put(trace->current);
1974                 trace->current = thread__get(thread);
1975         }
1976         err = 0;
1977 out_put:
1978         thread__put(thread);
1979         return err;
1980 }
1981
1982 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
1983                            union perf_event *event __maybe_unused,
1984                            struct perf_sample *sample)
1985 {
1986         long ret;
1987         u64 duration = 0;
1988         struct thread *thread;
1989         int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
1990         struct syscall *sc = trace__syscall_info(trace, evsel, id);
1991         struct thread_trace *ttrace;
1992
1993         if (sc == NULL)
1994                 return -1;
1995
1996         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
1997         ttrace = thread__trace(thread, trace->output);
1998         if (ttrace == NULL)
1999                 goto out_put;
2000
2001         if (trace->summary)
2002                 thread__update_stats(ttrace, id, sample);
2003
2004         ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
2005
2006         if (id == trace->audit.open_id && ret >= 0 && trace->last_vfs_getname) {
2007                 trace__set_fd_pathname(thread, ret, trace->last_vfs_getname);
2008                 trace->last_vfs_getname = NULL;
2009                 ++trace->stats.vfs_getname;
2010         }
2011
2012         ttrace->exit_time = sample->time;
2013
2014         if (ttrace->entry_time) {
2015                 duration = sample->time - ttrace->entry_time;
2016                 if (trace__filter_duration(trace, duration))
2017                         goto out;
2018         } else if (trace->duration_filter)
2019                 goto out;
2020
2021         if (trace->summary_only)
2022                 goto out;
2023
2024         trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
2025
2026         if (ttrace->entry_pending) {
2027                 fprintf(trace->output, "%-70s", ttrace->entry_str);
2028         } else {
2029                 fprintf(trace->output, " ... [");
2030                 color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
2031                 fprintf(trace->output, "]: %s()", sc->name);
2032         }
2033
2034         if (sc->fmt == NULL) {
2035 signed_print:
2036                 fprintf(trace->output, ") = %ld", ret);
2037         } else if (ret < 0 && sc->fmt->errmsg) {
2038                 char bf[STRERR_BUFSIZE];
2039                 const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
2040                            *e = audit_errno_to_name(-ret);
2041
2042                 fprintf(trace->output, ") = -1 %s %s", e, emsg);
2043         } else if (ret == 0 && sc->fmt->timeout)
2044                 fprintf(trace->output, ") = 0 Timeout");
2045         else if (sc->fmt->hexret)
2046                 fprintf(trace->output, ") = %#lx", ret);
2047         else
2048                 goto signed_print;
2049
2050         fputc('\n', trace->output);
2051 out:
2052         ttrace->entry_pending = false;
2053         err = 0;
2054 out_put:
2055         thread__put(thread);
2056         return err;
2057 }
2058
2059 static int trace__vfs_getname(struct trace *trace, struct perf_evsel *evsel,
2060                               union perf_event *event __maybe_unused,
2061                               struct perf_sample *sample)
2062 {
2063         struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2064         struct thread_trace *ttrace;
2065         size_t filename_len, entry_str_len, to_move;
2066         ssize_t remaining_space;
2067         char *pos;
2068         const char *filename;
2069
2070         trace->last_vfs_getname = perf_evsel__rawptr(evsel, sample, "pathname");
2071
2072         if (!thread)
2073                 goto out;
2074
2075         ttrace = thread__priv(thread);
2076         if (!ttrace)
2077                 goto out;
2078
2079         if (!ttrace->filename.ptr)
2080                 goto out;
2081
2082         entry_str_len = strlen(ttrace->entry_str);
2083         remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
2084         if (remaining_space <= 0)
2085                 goto out;
2086
2087         filename = trace->last_vfs_getname;
2088         filename_len = strlen(filename);
2089         if (filename_len > (size_t)remaining_space) {
2090                 filename += filename_len - remaining_space;
2091                 filename_len = remaining_space;
2092         }
2093
2094         to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
2095         pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
2096         memmove(pos + filename_len, pos, to_move);
2097         memcpy(pos, filename, filename_len);
2098
2099         ttrace->filename.ptr = 0;
2100         ttrace->filename.entry_str_pos = 0;
2101 out:
2102         return 0;
2103 }
2104
2105 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
2106                                      union perf_event *event __maybe_unused,
2107                                      struct perf_sample *sample)
2108 {
2109         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
2110         double runtime_ms = (double)runtime / NSEC_PER_MSEC;
2111         struct thread *thread = machine__findnew_thread(trace->host,
2112                                                         sample->pid,
2113                                                         sample->tid);
2114         struct thread_trace *ttrace = thread__trace(thread, trace->output);
2115
2116         if (ttrace == NULL)
2117                 goto out_dump;
2118
2119         ttrace->runtime_ms += runtime_ms;
2120         trace->runtime_ms += runtime_ms;
2121         thread__put(thread);
2122         return 0;
2123
2124 out_dump:
2125         fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
2126                evsel->name,
2127                perf_evsel__strval(evsel, sample, "comm"),
2128                (pid_t)perf_evsel__intval(evsel, sample, "pid"),
2129                runtime,
2130                perf_evsel__intval(evsel, sample, "vruntime"));
2131         thread__put(thread);
2132         return 0;
2133 }
2134
2135 static int trace__event_handler(struct trace *trace, struct perf_evsel *evsel,
2136                                 union perf_event *event __maybe_unused,
2137                                 struct perf_sample *sample)
2138 {
2139         trace__printf_interrupted_entry(trace, sample);
2140         trace__fprintf_tstamp(trace, sample->time, trace->output);
2141
2142         if (trace->trace_syscalls)
2143                 fprintf(trace->output, "(         ): ");
2144
2145         fprintf(trace->output, "%s:", evsel->name);
2146
2147         if (evsel->tp_format) {
2148                 event_format__fprintf(evsel->tp_format, sample->cpu,
2149                                       sample->raw_data, sample->raw_size,
2150                                       trace->output);
2151         }
2152
2153         fprintf(trace->output, ")\n");
2154         return 0;
2155 }
2156
2157 static void print_location(FILE *f, struct perf_sample *sample,
2158                            struct addr_location *al,
2159                            bool print_dso, bool print_sym)
2160 {
2161
2162         if ((verbose || print_dso) && al->map)
2163                 fprintf(f, "%s@", al->map->dso->long_name);
2164
2165         if ((verbose || print_sym) && al->sym)
2166                 fprintf(f, "%s+0x%" PRIx64, al->sym->name,
2167                         al->addr - al->sym->start);
2168         else if (al->map)
2169                 fprintf(f, "0x%" PRIx64, al->addr);
2170         else
2171                 fprintf(f, "0x%" PRIx64, sample->addr);
2172 }
2173
2174 static int trace__pgfault(struct trace *trace,
2175                           struct perf_evsel *evsel,
2176                           union perf_event *event,
2177                           struct perf_sample *sample)
2178 {
2179         struct thread *thread;
2180         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2181         struct addr_location al;
2182         char map_type = 'd';
2183         struct thread_trace *ttrace;
2184         int err = -1;
2185
2186         thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2187         ttrace = thread__trace(thread, trace->output);
2188         if (ttrace == NULL)
2189                 goto out_put;
2190
2191         if (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)
2192                 ttrace->pfmaj++;
2193         else
2194                 ttrace->pfmin++;
2195
2196         if (trace->summary_only)
2197                 goto out;
2198
2199         thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
2200                               sample->ip, &al);
2201
2202         trace__fprintf_entry_head(trace, thread, 0, sample->time, trace->output);
2203
2204         fprintf(trace->output, "%sfault [",
2205                 evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
2206                 "maj" : "min");
2207
2208         print_location(trace->output, sample, &al, false, true);
2209
2210         fprintf(trace->output, "] => ");
2211
2212         thread__find_addr_location(thread, cpumode, MAP__VARIABLE,
2213                                    sample->addr, &al);
2214
2215         if (!al.map) {
2216                 thread__find_addr_location(thread, cpumode,
2217                                            MAP__FUNCTION, sample->addr, &al);
2218
2219                 if (al.map)
2220                         map_type = 'x';
2221                 else
2222                         map_type = '?';
2223         }
2224
2225         print_location(trace->output, sample, &al, true, false);
2226
2227         fprintf(trace->output, " (%c%c)\n", map_type, al.level);
2228 out:
2229         err = 0;
2230 out_put:
2231         thread__put(thread);
2232         return err;
2233 }
2234
2235 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
2236 {
2237         if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
2238             (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
2239                 return false;
2240
2241         if (trace->pid_list || trace->tid_list)
2242                 return true;
2243
2244         return false;
2245 }
2246
2247 static int trace__process_sample(struct perf_tool *tool,
2248                                  union perf_event *event,
2249                                  struct perf_sample *sample,
2250                                  struct perf_evsel *evsel,
2251                                  struct machine *machine __maybe_unused)
2252 {
2253         struct trace *trace = container_of(tool, struct trace, tool);
2254         int err = 0;
2255
2256         tracepoint_handler handler = evsel->handler;
2257
2258         if (skip_sample(trace, sample))
2259                 return 0;
2260
2261         if (!trace->full_time && trace->base_time == 0)
2262                 trace->base_time = sample->time;
2263
2264         if (handler) {
2265                 ++trace->nr_events;
2266                 handler(trace, evsel, event, sample);
2267         }
2268
2269         return err;
2270 }
2271
2272 static int parse_target_str(struct trace *trace)
2273 {
2274         if (trace->opts.target.pid) {
2275                 trace->pid_list = intlist__new(trace->opts.target.pid);
2276                 if (trace->pid_list == NULL) {
2277                         pr_err("Error parsing process id string\n");
2278                         return -EINVAL;
2279                 }
2280         }
2281
2282         if (trace->opts.target.tid) {
2283                 trace->tid_list = intlist__new(trace->opts.target.tid);
2284                 if (trace->tid_list == NULL) {
2285                         pr_err("Error parsing thread id string\n");
2286                         return -EINVAL;
2287                 }
2288         }
2289
2290         return 0;
2291 }
2292
2293 static int trace__record(struct trace *trace, int argc, const char **argv)
2294 {
2295         unsigned int rec_argc, i, j;
2296         const char **rec_argv;
2297         const char * const record_args[] = {
2298                 "record",
2299                 "-R",
2300                 "-m", "1024",
2301                 "-c", "1",
2302         };
2303
2304         const char * const sc_args[] = { "-e", };
2305         unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
2306         const char * const majpf_args[] = { "-e", "major-faults" };
2307         unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
2308         const char * const minpf_args[] = { "-e", "minor-faults" };
2309         unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
2310
2311         /* +1 is for the event string below */
2312         rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 1 +
2313                 majpf_args_nr + minpf_args_nr + argc;
2314         rec_argv = calloc(rec_argc + 1, sizeof(char *));
2315
2316         if (rec_argv == NULL)
2317                 return -ENOMEM;
2318
2319         j = 0;
2320         for (i = 0; i < ARRAY_SIZE(record_args); i++)
2321                 rec_argv[j++] = record_args[i];
2322
2323         if (trace->trace_syscalls) {
2324                 for (i = 0; i < sc_args_nr; i++)
2325                         rec_argv[j++] = sc_args[i];
2326
2327                 /* event string may be different for older kernels - e.g., RHEL6 */
2328                 if (is_valid_tracepoint("raw_syscalls:sys_enter"))
2329                         rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
2330                 else if (is_valid_tracepoint("syscalls:sys_enter"))
2331                         rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
2332                 else {
2333                         pr_err("Neither raw_syscalls nor syscalls events exist.\n");
2334                         return -1;
2335                 }
2336         }
2337
2338         if (trace->trace_pgfaults & TRACE_PFMAJ)
2339                 for (i = 0; i < majpf_args_nr; i++)
2340                         rec_argv[j++] = majpf_args[i];
2341
2342         if (trace->trace_pgfaults & TRACE_PFMIN)
2343                 for (i = 0; i < minpf_args_nr; i++)
2344                         rec_argv[j++] = minpf_args[i];
2345
2346         for (i = 0; i < (unsigned int)argc; i++)
2347                 rec_argv[j++] = argv[i];
2348
2349         return cmd_record(j, rec_argv, NULL);
2350 }
2351
2352 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
2353
2354 static bool perf_evlist__add_vfs_getname(struct perf_evlist *evlist)
2355 {
2356         struct perf_evsel *evsel = perf_evsel__newtp("probe", "vfs_getname");
2357         if (evsel == NULL)
2358                 return false;
2359
2360         if (perf_evsel__field(evsel, "pathname") == NULL) {
2361                 perf_evsel__delete(evsel);
2362                 return false;
2363         }
2364
2365         evsel->handler = trace__vfs_getname;
2366         perf_evlist__add(evlist, evsel);
2367         return true;
2368 }
2369
2370 static int perf_evlist__add_pgfault(struct perf_evlist *evlist,
2371                                     u64 config)
2372 {
2373         struct perf_evsel *evsel;
2374         struct perf_event_attr attr = {
2375                 .type = PERF_TYPE_SOFTWARE,
2376                 .mmap_data = 1,
2377         };
2378
2379         attr.config = config;
2380         attr.sample_period = 1;
2381
2382         event_attr_init(&attr);
2383
2384         evsel = perf_evsel__new(&attr);
2385         if (!evsel)
2386                 return -ENOMEM;
2387
2388         evsel->handler = trace__pgfault;
2389         perf_evlist__add(evlist, evsel);
2390
2391         return 0;
2392 }
2393
2394 static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
2395 {
2396         const u32 type = event->header.type;
2397         struct perf_evsel *evsel;
2398
2399         if (!trace->full_time && trace->base_time == 0)
2400                 trace->base_time = sample->time;
2401
2402         if (type != PERF_RECORD_SAMPLE) {
2403                 trace__process_event(trace, trace->host, event, sample);
2404                 return;
2405         }
2406
2407         evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
2408         if (evsel == NULL) {
2409                 fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
2410                 return;
2411         }
2412
2413         if (evsel->attr.type == PERF_TYPE_TRACEPOINT &&
2414             sample->raw_data == NULL) {
2415                 fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
2416                        perf_evsel__name(evsel), sample->tid,
2417                        sample->cpu, sample->raw_size);
2418         } else {
2419                 tracepoint_handler handler = evsel->handler;
2420                 handler(trace, evsel, event, sample);
2421         }
2422 }
2423
2424 static int trace__add_syscall_newtp(struct trace *trace)
2425 {
2426         int ret = -1;
2427         struct perf_evlist *evlist = trace->evlist;
2428         struct perf_evsel *sys_enter, *sys_exit;
2429
2430         sys_enter = perf_evsel__syscall_newtp("sys_enter", trace__sys_enter);
2431         if (sys_enter == NULL)
2432                 goto out;
2433
2434         if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
2435                 goto out_delete_sys_enter;
2436
2437         sys_exit = perf_evsel__syscall_newtp("sys_exit", trace__sys_exit);
2438         if (sys_exit == NULL)
2439                 goto out_delete_sys_enter;
2440
2441         if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
2442                 goto out_delete_sys_exit;
2443
2444         perf_evlist__add(evlist, sys_enter);
2445         perf_evlist__add(evlist, sys_exit);
2446
2447         trace->syscalls.events.sys_enter = sys_enter;
2448         trace->syscalls.events.sys_exit  = sys_exit;
2449
2450         ret = 0;
2451 out:
2452         return ret;
2453
2454 out_delete_sys_exit:
2455         perf_evsel__delete_priv(sys_exit);
2456 out_delete_sys_enter:
2457         perf_evsel__delete_priv(sys_enter);
2458         goto out;
2459 }
2460
2461 static int trace__set_ev_qualifier_filter(struct trace *trace)
2462 {
2463         int err = -1;
2464         char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
2465                                                 trace->ev_qualifier_ids.nr,
2466                                                 trace->ev_qualifier_ids.entries);
2467
2468         if (filter == NULL)
2469                 goto out_enomem;
2470
2471         if (!perf_evsel__append_filter(trace->syscalls.events.sys_enter, "&&", filter))
2472                 err = perf_evsel__append_filter(trace->syscalls.events.sys_exit, "&&", filter);
2473
2474         free(filter);
2475 out:
2476         return err;
2477 out_enomem:
2478         errno = ENOMEM;
2479         goto out;
2480 }
2481
2482 static int trace__run(struct trace *trace, int argc, const char **argv)
2483 {
2484         struct perf_evlist *evlist = trace->evlist;
2485         struct perf_evsel *evsel;
2486         int err = -1, i;
2487         unsigned long before;
2488         const bool forks = argc > 0;
2489         bool draining = false;
2490
2491         trace->live = true;
2492
2493         if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
2494                 goto out_error_raw_syscalls;
2495
2496         if (trace->trace_syscalls)
2497                 trace->vfs_getname = perf_evlist__add_vfs_getname(evlist);
2498
2499         if ((trace->trace_pgfaults & TRACE_PFMAJ) &&
2500             perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MAJ)) {
2501                 goto out_error_mem;
2502         }
2503
2504         if ((trace->trace_pgfaults & TRACE_PFMIN) &&
2505             perf_evlist__add_pgfault(evlist, PERF_COUNT_SW_PAGE_FAULTS_MIN))
2506                 goto out_error_mem;
2507
2508         if (trace->sched &&
2509             perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
2510                                    trace__sched_stat_runtime))
2511                 goto out_error_sched_stat_runtime;
2512
2513         err = perf_evlist__create_maps(evlist, &trace->opts.target);
2514         if (err < 0) {
2515                 fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
2516                 goto out_delete_evlist;
2517         }
2518
2519         err = trace__symbols_init(trace, evlist);
2520         if (err < 0) {
2521                 fprintf(trace->output, "Problems initializing symbol libraries!\n");
2522                 goto out_delete_evlist;
2523         }
2524
2525         perf_evlist__config(evlist, &trace->opts);
2526
2527         signal(SIGCHLD, sig_handler);
2528         signal(SIGINT, sig_handler);
2529
2530         if (forks) {
2531                 err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
2532                                                     argv, false, NULL);
2533                 if (err < 0) {
2534                         fprintf(trace->output, "Couldn't run the workload!\n");
2535                         goto out_delete_evlist;
2536                 }
2537         }
2538
2539         err = perf_evlist__open(evlist);
2540         if (err < 0)
2541                 goto out_error_open;
2542
2543         /*
2544          * Better not use !target__has_task() here because we need to cover the
2545          * case where no threads were specified in the command line, but a
2546          * workload was, and in that case we will fill in the thread_map when
2547          * we fork the workload in perf_evlist__prepare_workload.
2548          */
2549         if (trace->filter_pids.nr > 0)
2550                 err = perf_evlist__set_filter_pids(evlist, trace->filter_pids.nr, trace->filter_pids.entries);
2551         else if (thread_map__pid(evlist->threads, 0) == -1)
2552                 err = perf_evlist__set_filter_pid(evlist, getpid());
2553
2554         if (err < 0)
2555                 goto out_error_mem;
2556
2557         if (trace->ev_qualifier_ids.nr > 0) {
2558                 err = trace__set_ev_qualifier_filter(trace);
2559                 if (err < 0)
2560                         goto out_errno;
2561
2562                 pr_debug("event qualifier tracepoint filter: %s\n",
2563                          trace->syscalls.events.sys_exit->filter);
2564         }
2565
2566         err = perf_evlist__apply_filters(evlist, &evsel);
2567         if (err < 0)
2568                 goto out_error_apply_filters;
2569
2570         err = perf_evlist__mmap(evlist, trace->opts.mmap_pages, false);
2571         if (err < 0)
2572                 goto out_error_mmap;
2573
2574         if (!target__none(&trace->opts.target))
2575                 perf_evlist__enable(evlist);
2576
2577         if (forks)
2578                 perf_evlist__start_workload(evlist);
2579
2580         trace->multiple_threads = thread_map__pid(evlist->threads, 0) == -1 ||
2581                                   evlist->threads->nr > 1 ||
2582                                   perf_evlist__first(evlist)->attr.inherit;
2583 again:
2584         before = trace->nr_events;
2585
2586         for (i = 0; i < evlist->nr_mmaps; i++) {
2587                 union perf_event *event;
2588
2589                 while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
2590                         struct perf_sample sample;
2591
2592                         ++trace->nr_events;
2593
2594                         err = perf_evlist__parse_sample(evlist, event, &sample);
2595                         if (err) {
2596                                 fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
2597                                 goto next_event;
2598                         }
2599
2600                         trace__handle_event(trace, event, &sample);
2601 next_event:
2602                         perf_evlist__mmap_consume(evlist, i);
2603
2604                         if (interrupted)
2605                                 goto out_disable;
2606
2607                         if (done && !draining) {
2608                                 perf_evlist__disable(evlist);
2609                                 draining = true;
2610                         }
2611                 }
2612         }
2613
2614         if (trace->nr_events == before) {
2615                 int timeout = done ? 100 : -1;
2616
2617                 if (!draining && perf_evlist__poll(evlist, timeout) > 0) {
2618                         if (perf_evlist__filter_pollfd(evlist, POLLERR | POLLHUP) == 0)
2619                                 draining = true;
2620
2621                         goto again;
2622                 }
2623         } else {
2624                 goto again;
2625         }
2626
2627 out_disable:
2628         thread__zput(trace->current);
2629
2630         perf_evlist__disable(evlist);
2631
2632         if (!err) {
2633                 if (trace->summary)
2634                         trace__fprintf_thread_summary(trace, trace->output);
2635
2636                 if (trace->show_tool_stats) {
2637                         fprintf(trace->output, "Stats:\n "
2638                                                " vfs_getname : %" PRIu64 "\n"
2639                                                " proc_getname: %" PRIu64 "\n",
2640                                 trace->stats.vfs_getname,
2641                                 trace->stats.proc_getname);
2642                 }
2643         }
2644
2645 out_delete_evlist:
2646         perf_evlist__delete(evlist);
2647         trace->evlist = NULL;
2648         trace->live = false;
2649         return err;
2650 {
2651         char errbuf[BUFSIZ];
2652
2653 out_error_sched_stat_runtime:
2654         debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
2655         goto out_error;
2656
2657 out_error_raw_syscalls:
2658         debugfs__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
2659         goto out_error;
2660
2661 out_error_mmap:
2662         perf_evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
2663         goto out_error;
2664
2665 out_error_open:
2666         perf_evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
2667
2668 out_error:
2669         fprintf(trace->output, "%s\n", errbuf);
2670         goto out_delete_evlist;
2671
2672 out_error_apply_filters:
2673         fprintf(trace->output,
2674                 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
2675                 evsel->filter, perf_evsel__name(evsel), errno,
2676                 strerror_r(errno, errbuf, sizeof(errbuf)));
2677         goto out_delete_evlist;
2678 }
2679 out_error_mem:
2680         fprintf(trace->output, "Not enough memory to run!\n");
2681         goto out_delete_evlist;
2682
2683 out_errno:
2684         fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
2685         goto out_delete_evlist;
2686 }
2687
2688 static int trace__replay(struct trace *trace)
2689 {
2690         const struct perf_evsel_str_handler handlers[] = {
2691                 { "probe:vfs_getname",       trace__vfs_getname, },
2692         };
2693         struct perf_data_file file = {
2694                 .path  = input_name,
2695                 .mode  = PERF_DATA_MODE_READ,
2696                 .force = trace->force,
2697         };
2698         struct perf_session *session;
2699         struct perf_evsel *evsel;
2700         int err = -1;
2701
2702         trace->tool.sample        = trace__process_sample;
2703         trace->tool.mmap          = perf_event__process_mmap;
2704         trace->tool.mmap2         = perf_event__process_mmap2;
2705         trace->tool.comm          = perf_event__process_comm;
2706         trace->tool.exit          = perf_event__process_exit;
2707         trace->tool.fork          = perf_event__process_fork;
2708         trace->tool.attr          = perf_event__process_attr;
2709         trace->tool.tracing_data = perf_event__process_tracing_data;
2710         trace->tool.build_id      = perf_event__process_build_id;
2711
2712         trace->tool.ordered_events = true;
2713         trace->tool.ordering_requires_timestamps = true;
2714
2715         /* add tid to output */
2716         trace->multiple_threads = true;
2717
2718         session = perf_session__new(&file, false, &trace->tool);
2719         if (session == NULL)
2720                 return -1;
2721
2722         if (symbol__init(&session->header.env) < 0)
2723                 goto out;
2724
2725         trace->host = &session->machines.host;
2726
2727         err = perf_session__set_tracepoints_handlers(session, handlers);
2728         if (err)
2729                 goto out;
2730
2731         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2732                                                      "raw_syscalls:sys_enter");
2733         /* older kernels have syscalls tp versus raw_syscalls */
2734         if (evsel == NULL)
2735                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2736                                                              "syscalls:sys_enter");
2737
2738         if (evsel &&
2739             (perf_evsel__init_syscall_tp(evsel, trace__sys_enter) < 0 ||
2740             perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
2741                 pr_err("Error during initialize raw_syscalls:sys_enter event\n");
2742                 goto out;
2743         }
2744
2745         evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2746                                                      "raw_syscalls:sys_exit");
2747         if (evsel == NULL)
2748                 evsel = perf_evlist__find_tracepoint_by_name(session->evlist,
2749                                                              "syscalls:sys_exit");
2750         if (evsel &&
2751             (perf_evsel__init_syscall_tp(evsel, trace__sys_exit) < 0 ||
2752             perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
2753                 pr_err("Error during initialize raw_syscalls:sys_exit event\n");
2754                 goto out;
2755         }
2756
2757         evlist__for_each(session->evlist, evsel) {
2758                 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
2759                     (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
2760                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
2761                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS))
2762                         evsel->handler = trace__pgfault;
2763         }
2764
2765         err = parse_target_str(trace);
2766         if (err != 0)
2767                 goto out;
2768
2769         setup_pager();
2770
2771         err = perf_session__process_events(session);
2772         if (err)
2773                 pr_err("Failed to process events, error %d", err);
2774
2775         else if (trace->summary)
2776                 trace__fprintf_thread_summary(trace, trace->output);
2777
2778 out:
2779         perf_session__delete(session);
2780
2781         return err;
2782 }
2783
2784 static size_t trace__fprintf_threads_header(FILE *fp)
2785 {
2786         size_t printed;
2787
2788         printed  = fprintf(fp, "\n Summary of events:\n\n");
2789
2790         return printed;
2791 }
2792
2793 static size_t thread__dump_stats(struct thread_trace *ttrace,
2794                                  struct trace *trace, FILE *fp)
2795 {
2796         struct stats *stats;
2797         size_t printed = 0;
2798         struct syscall *sc;
2799         struct int_node *inode = intlist__first(ttrace->syscall_stats);
2800
2801         if (inode == NULL)
2802                 return 0;
2803
2804         printed += fprintf(fp, "\n");
2805
2806         printed += fprintf(fp, "   syscall            calls    total       min       avg       max      stddev\n");
2807         printed += fprintf(fp, "                               (msec)    (msec)    (msec)    (msec)        (%%)\n");
2808         printed += fprintf(fp, "   --------------- -------- --------- --------- --------- ---------     ------\n");
2809
2810         /* each int_node is a syscall */
2811         while (inode) {
2812                 stats = inode->priv;
2813                 if (stats) {
2814                         double min = (double)(stats->min) / NSEC_PER_MSEC;
2815                         double max = (double)(stats->max) / NSEC_PER_MSEC;
2816                         double avg = avg_stats(stats);
2817                         double pct;
2818                         u64 n = (u64) stats->n;
2819
2820                         pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
2821                         avg /= NSEC_PER_MSEC;
2822
2823                         sc = &trace->syscalls.table[inode->i];
2824                         printed += fprintf(fp, "   %-15s", sc->name);
2825                         printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
2826                                            n, avg * n, min, avg);
2827                         printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
2828                 }
2829
2830                 inode = intlist__next(inode);
2831         }
2832
2833         printed += fprintf(fp, "\n\n");
2834
2835         return printed;
2836 }
2837
2838 /* struct used to pass data to per-thread function */
2839 struct summary_data {
2840         FILE *fp;
2841         struct trace *trace;
2842         size_t printed;
2843 };
2844
2845 static int trace__fprintf_one_thread(struct thread *thread, void *priv)
2846 {
2847         struct summary_data *data = priv;
2848         FILE *fp = data->fp;
2849         size_t printed = data->printed;
2850         struct trace *trace = data->trace;
2851         struct thread_trace *ttrace = thread__priv(thread);
2852         double ratio;
2853
2854         if (ttrace == NULL)
2855                 return 0;
2856
2857         ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
2858
2859         printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread->tid);
2860         printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
2861         printed += fprintf(fp, "%.1f%%", ratio);
2862         if (ttrace->pfmaj)
2863                 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
2864         if (ttrace->pfmin)
2865                 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
2866         printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
2867         printed += thread__dump_stats(ttrace, trace, fp);
2868
2869         data->printed += printed;
2870
2871         return 0;
2872 }
2873
2874 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
2875 {
2876         struct summary_data data = {
2877                 .fp = fp,
2878                 .trace = trace
2879         };
2880         data.printed = trace__fprintf_threads_header(fp);
2881
2882         machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
2883
2884         return data.printed;
2885 }
2886
2887 static int trace__set_duration(const struct option *opt, const char *str,
2888                                int unset __maybe_unused)
2889 {
2890         struct trace *trace = opt->value;
2891
2892         trace->duration_filter = atof(str);
2893         return 0;
2894 }
2895
2896 static int trace__set_filter_pids(const struct option *opt, const char *str,
2897                                   int unset __maybe_unused)
2898 {
2899         int ret = -1;
2900         size_t i;
2901         struct trace *trace = opt->value;
2902         /*
2903          * FIXME: introduce a intarray class, plain parse csv and create a
2904          * { int nr, int entries[] } struct...
2905          */
2906         struct intlist *list = intlist__new(str);
2907
2908         if (list == NULL)
2909                 return -1;
2910
2911         i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
2912         trace->filter_pids.entries = calloc(i, sizeof(pid_t));
2913
2914         if (trace->filter_pids.entries == NULL)
2915                 goto out;
2916
2917         trace->filter_pids.entries[0] = getpid();
2918
2919         for (i = 1; i < trace->filter_pids.nr; ++i)
2920                 trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
2921
2922         intlist__delete(list);
2923         ret = 0;
2924 out:
2925         return ret;
2926 }
2927
2928 static int trace__open_output(struct trace *trace, const char *filename)
2929 {
2930         struct stat st;
2931
2932         if (!stat(filename, &st) && st.st_size) {
2933                 char oldname[PATH_MAX];
2934
2935                 scnprintf(oldname, sizeof(oldname), "%s.old", filename);
2936                 unlink(oldname);
2937                 rename(filename, oldname);
2938         }
2939
2940         trace->output = fopen(filename, "w");
2941
2942         return trace->output == NULL ? -errno : 0;
2943 }
2944
2945 static int parse_pagefaults(const struct option *opt, const char *str,
2946                             int unset __maybe_unused)
2947 {
2948         int *trace_pgfaults = opt->value;
2949
2950         if (strcmp(str, "all") == 0)
2951                 *trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
2952         else if (strcmp(str, "maj") == 0)
2953                 *trace_pgfaults |= TRACE_PFMAJ;
2954         else if (strcmp(str, "min") == 0)
2955                 *trace_pgfaults |= TRACE_PFMIN;
2956         else
2957                 return -1;
2958
2959         return 0;
2960 }
2961
2962 static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
2963 {
2964         struct perf_evsel *evsel;
2965
2966         evlist__for_each(evlist, evsel)
2967                 evsel->handler = handler;
2968 }
2969
2970 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
2971 {
2972         const char *trace_usage[] = {
2973                 "perf trace [<options>] [<command>]",
2974                 "perf trace [<options>] -- <command> [<options>]",
2975                 "perf trace record [<options>] [<command>]",
2976                 "perf trace record [<options>] -- <command> [<options>]",
2977                 NULL
2978         };
2979         struct trace trace = {
2980                 .audit = {
2981                         .machine = audit_detect_machine(),
2982                         .open_id = audit_name_to_syscall("open", trace.audit.machine),
2983                 },
2984                 .syscalls = {
2985                         . max = -1,
2986                 },
2987                 .opts = {
2988                         .target = {
2989                                 .uid       = UINT_MAX,
2990                                 .uses_mmap = true,
2991                         },
2992                         .user_freq     = UINT_MAX,
2993                         .user_interval = ULLONG_MAX,
2994                         .no_buffering  = true,
2995                         .mmap_pages    = UINT_MAX,
2996                         .proc_map_timeout  = 500,
2997                 },
2998                 .output = stderr,
2999                 .show_comm = true,
3000                 .trace_syscalls = true,
3001         };
3002         const char *output_name = NULL;
3003         const char *ev_qualifier_str = NULL;
3004         const struct option trace_options[] = {
3005         OPT_CALLBACK(0, "event", &trace.evlist, "event",
3006                      "event selector. use 'perf list' to list available events",
3007                      parse_events_option),
3008         OPT_BOOLEAN(0, "comm", &trace.show_comm,
3009                     "show the thread COMM next to its id"),
3010         OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
3011         OPT_STRING('e', "expr", &ev_qualifier_str, "expr", "list of syscalls to trace"),
3012         OPT_STRING('o', "output", &output_name, "file", "output file name"),
3013         OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
3014         OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
3015                     "trace events on existing process id"),
3016         OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
3017                     "trace events on existing thread id"),
3018         OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
3019                      "pids to filter (by the kernel)", trace__set_filter_pids),
3020         OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
3021                     "system-wide collection from all CPUs"),
3022         OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
3023                     "list of cpus to monitor"),
3024         OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
3025                     "child tasks do not inherit counters"),
3026         OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
3027                      "number of mmap data pages",
3028                      perf_evlist__parse_mmap_pages),
3029         OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
3030                    "user to profile"),
3031         OPT_CALLBACK(0, "duration", &trace, "float",
3032                      "show only events with duration > N.M ms",
3033                      trace__set_duration),
3034         OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
3035         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
3036         OPT_BOOLEAN('T', "time", &trace.full_time,
3037                     "Show full timestamp, not time relative to first start"),
3038         OPT_BOOLEAN('s', "summary", &trace.summary_only,
3039                     "Show only syscall summary with statistics"),
3040         OPT_BOOLEAN('S', "with-summary", &trace.summary,
3041                     "Show all syscalls and summary with statistics"),
3042         OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
3043                      "Trace pagefaults", parse_pagefaults, "maj"),
3044         OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
3045         OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
3046         OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout,
3047                         "per thread proc mmap processing timeout in ms"),
3048         OPT_END()
3049         };
3050         const char * const trace_subcommands[] = { "record", NULL };
3051         int err;
3052         char bf[BUFSIZ];
3053
3054         signal(SIGSEGV, sighandler_dump_stack);
3055         signal(SIGFPE, sighandler_dump_stack);
3056
3057         trace.evlist = perf_evlist__new();
3058
3059         if (trace.evlist == NULL) {
3060                 pr_err("Not enough memory to run!\n");
3061                 err = -ENOMEM;
3062                 goto out;
3063         }
3064
3065         argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
3066                                  trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
3067
3068         if (trace.trace_pgfaults) {
3069                 trace.opts.sample_address = true;
3070                 trace.opts.sample_time = true;
3071         }
3072
3073         if (trace.evlist->nr_entries > 0)
3074                 evlist__set_evsel_handler(trace.evlist, trace__event_handler);
3075
3076         if ((argc >= 1) && (strcmp(argv[0], "record") == 0))
3077                 return trace__record(&trace, argc-1, &argv[1]);
3078
3079         /* summary_only implies summary option, but don't overwrite summary if set */
3080         if (trace.summary_only)
3081                 trace.summary = trace.summary_only;
3082
3083         if (!trace.trace_syscalls && !trace.trace_pgfaults &&
3084             trace.evlist->nr_entries == 0 /* Was --events used? */) {
3085                 pr_err("Please specify something to trace.\n");
3086                 return -1;
3087         }
3088
3089         if (output_name != NULL) {
3090                 err = trace__open_output(&trace, output_name);
3091                 if (err < 0) {
3092                         perror("failed to create output file");
3093                         goto out;
3094                 }
3095         }
3096
3097         if (ev_qualifier_str != NULL) {
3098                 const char *s = ev_qualifier_str;
3099                 struct strlist_config slist_config = {
3100                         .dirname = system_path(STRACE_GROUPS_DIR),
3101                 };
3102
3103                 trace.not_ev_qualifier = *s == '!';
3104                 if (trace.not_ev_qualifier)
3105                         ++s;
3106                 trace.ev_qualifier = strlist__new(s, &slist_config);
3107                 if (trace.ev_qualifier == NULL) {
3108                         fputs("Not enough memory to parse event qualifier",
3109                               trace.output);
3110                         err = -ENOMEM;
3111                         goto out_close;
3112                 }
3113
3114                 err = trace__validate_ev_qualifier(&trace);
3115                 if (err)
3116                         goto out_close;
3117         }
3118
3119         err = target__validate(&trace.opts.target);
3120         if (err) {
3121                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3122                 fprintf(trace.output, "%s", bf);
3123                 goto out_close;
3124         }
3125
3126         err = target__parse_uid(&trace.opts.target);
3127         if (err) {
3128                 target__strerror(&trace.opts.target, err, bf, sizeof(bf));
3129                 fprintf(trace.output, "%s", bf);
3130                 goto out_close;
3131         }
3132
3133         if (!argc && target__none(&trace.opts.target))
3134                 trace.opts.target.system_wide = true;
3135
3136         if (input_name)
3137                 err = trace__replay(&trace);
3138         else
3139                 err = trace__run(&trace, argc, argv);
3140
3141 out_close:
3142         if (output_name != NULL)
3143                 fclose(trace.output);
3144 out:
3145         return err;
3146 }