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