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