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