tools/perf/builtin-trace.c

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