builtin-trace.c

   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
  17#include "util/record.h"
  18#include <api/fs/tracing_path.h>
  19#ifdef HAVE_LIBBPF_SUPPORT
  20#include <bpf/bpf.h>
  21#include <bpf/libbpf.h>
  22#include <bpf/btf.h>
  23#endif
  24#include "util/bpf_map.h"
  25#include "util/rlimit.h"
  26#include "builtin.h"
  27#include "util/cgroup.h"
  28#include "util/color.h"
  29#include "util/config.h"
  30#include "util/debug.h"
  31#include "util/dso.h"
  32#include "util/env.h"
  33#include "util/event.h"
  34#include "util/evsel.h"
  35#include "util/evsel_fprintf.h"
  36#include "util/synthetic-events.h"
  37#include "util/evlist.h"
  38#include "util/evswitch.h"
  39#include "util/hashmap.h"
  40#include "util/mmap.h"
  41#include <subcmd/pager.h>
  42#include <subcmd/exec-cmd.h>
  43#include "util/machine.h"
  44#include "util/map.h"
  45#include "util/symbol.h"
  46#include "util/path.h"
  47#include "util/session.h"
  48#include "util/thread.h"
  49#include <subcmd/parse-options.h>
  50#include "util/strlist.h"
  51#include "util/intlist.h"
  52#include "util/thread_map.h"
  53#include "util/stat.h"
  54#include "util/tool.h"
  55#include "util/trace.h"
  56#include "util/util.h"
  57#include "trace/beauty/beauty.h"
  58#include "trace-event.h"
  59#include "util/parse-events.h"
  60#include "util/tracepoint.h"
  61#include "callchain.h"
  62#include "print_binary.h"
  63#include "string2.h"
  64#include "syscalltbl.h"
  65#include "../perf.h"
  66#include "trace_augment.h"
  67#include "dwarf-regs.h"
  68
  69#include <errno.h>
  70#include <inttypes.h>
  71#include <poll.h>
  72#include <signal.h>
  73#include <stdlib.h>
  74#include <string.h>
  75#include <linux/err.h>
  76#include <linux/filter.h>
  77#include <linux/kernel.h>
  78#include <linux/list_sort.h>
  79#include <linux/random.h>
  80#include <linux/stringify.h>
  81#include <linux/time64.h>
  82#include <linux/zalloc.h>
  83#include <fcntl.h>
  84#include <sys/sysmacros.h>
  85
  86#include <linux/ctype.h>
  87#include <perf/mmap.h>
  88#include <tools/libc_compat.h>
  89
  90#ifdef HAVE_LIBTRACEEVENT
  91#include <event-parse.h>
  92#endif
  93
  94#ifndef O_CLOEXEC
  95# define O_CLOEXEC		02000000
  96#endif
  97
  98#ifndef F_LINUX_SPECIFIC_BASE
  99# define F_LINUX_SPECIFIC_BASE	1024
 100#endif
 101
 102#define RAW_SYSCALL_ARGS_NUM	6
 103
 104/*
 105 * strtoul: Go from a string to a value, i.e. for msr: MSR_FS_BASE to 0xc0000100
 106 *
 107 * We have to explicitely mark the direction of the flow of data, if from the
 108 * kernel to user space or the other way around, since the BPF collector we
 109 * have so far copies only from user to kernel space, mark the arguments that
 110 * go that direction, so that we don´t end up collecting the previous contents
 111 * for syscall args that goes from kernel to user space.
 112 */
 113struct syscall_arg_fmt {
 114	size_t	   (*scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
 115	bool	   (*strtoul)(char *bf, size_t size, struct syscall_arg *arg, u64 *val);
 116	unsigned long (*mask_val)(struct syscall_arg *arg, unsigned long val);
 117	void	   *parm;
 118	const char *name;
 119	u16	   nr_entries; // for arrays
 120	bool	   from_user;
 121	bool	   show_zero;
 122#ifdef HAVE_LIBBPF_SUPPORT
 123	const struct btf_type *type;
 124	int	   type_id; /* used in btf_dump */
 125#endif
 126};
 127
 128struct syscall_fmt {
 129	const char *name;
 130	const char *alias;
 131	struct {
 132		const char *sys_enter,
 133			   *sys_exit;
 134	}	   bpf_prog_name;
 135	struct syscall_arg_fmt arg[RAW_SYSCALL_ARGS_NUM];
 136	u8	   nr_args;
 137	bool	   errpid;
 138	bool	   timeout;
 139	bool	   hexret;
 140};
 141
 142struct trace {
 143	struct perf_env		host_env;
 144	struct perf_tool	tool;
 145	struct {
 146		/** Sorted sycall numbers used by the trace. */
 147		struct syscall  **table;
 148		/** Size of table. */
 149		size_t		table_size;
 150		struct {
 151			struct evsel *sys_enter,
 152				*sys_exit,
 153				*bpf_output;
 154		}		events;
 155	} syscalls;
 156#ifdef HAVE_LIBBPF_SUPPORT
 157	struct btf		*btf;
 158#endif
 159	struct record_opts	opts;
 160	struct evlist	*evlist;
 161	struct machine		*host;
 162	struct thread		*current;
 163	struct cgroup		*cgroup;
 164	u64			base_time;
 165	FILE			*output;
 166	unsigned long		nr_events;
 167	unsigned long		nr_events_printed;
 168	unsigned long		max_events;
 169	struct evswitch		evswitch;
 170	struct strlist		*ev_qualifier;
 171	struct {
 172		size_t		nr;
 173		int		*entries;
 174	}			ev_qualifier_ids;
 175	struct {
 176		size_t		nr;
 177		pid_t		*entries;
 178		struct bpf_map  *map;
 179	}			filter_pids;
 180	/*
 181	 * TODO: The map is from an ID (aka system call number) to struct
 182	 * syscall_stats. If there is >1 e_machine, such as i386 and x86-64
 183	 * processes, then the stats here will gather wrong the statistics for
 184	 * the non EM_HOST system calls. A fix would be to add the e_machine
 185	 * into the key, but this would make the code inconsistent with the
 186	 * per-thread version.
 187	 */
 188	struct hashmap		*syscall_stats;
 189	double			duration_filter;
 190	double			runtime_ms;
 191	unsigned long		pfmaj, pfmin;
 192	struct {
 193		u64		vfs_getname,
 194				proc_getname;
 195	} stats;
 196	unsigned int		max_stack;
 197	unsigned int		min_stack;
 198	enum trace_summary_mode	summary_mode;
 199	int			max_summary;
 200	int			raw_augmented_syscalls_args_size;
 201	bool			raw_augmented_syscalls;
 202	bool			fd_path_disabled;
 203	bool			sort_events;
 204	bool			not_ev_qualifier;
 205	bool			live;
 206	bool			full_time;
 207	bool			sched;
 208	bool			multiple_threads;
 209	bool			summary;
 210	bool			summary_only;
 211	bool			errno_summary;
 212	bool			failure_only;
 213	bool			show_comm;
 214	bool			print_sample;
 215	bool			show_tool_stats;
 216	bool			trace_syscalls;
 217	bool			libtraceevent_print;
 218	bool			kernel_syscallchains;
 219	s16			args_alignment;
 220	bool			show_tstamp;
 221	bool			show_duration;
 222	bool			show_zeros;
 223	bool			show_arg_names;
 224	bool			show_string_prefix;
 225	bool			force;
 226	bool			vfs_getname;
 227	bool			force_btf;
 228	bool			summary_bpf;
 229	int			trace_pgfaults;
 230	char			*perfconfig_events;
 231	struct {
 232		struct ordered_events	data;
 233		u64			last;
 234	} oe;
 235	const char		*uid_str;
 236};
 237
 238static void trace__load_vmlinux_btf(struct trace *trace __maybe_unused)
 239{
 240#ifdef HAVE_LIBBPF_SUPPORT
 241	if (trace->btf != NULL)
 242		return;
 243
 244	trace->btf = btf__load_vmlinux_btf();
 245	if (verbose > 0) {
 246		fprintf(trace->output, trace->btf ? "vmlinux BTF loaded\n" :
 247						    "Failed to load vmlinux BTF\n");
 248	}
 249#endif
 250}
 251
 252struct tp_field {
 253	int offset;
 254	union {
 255		u64 (*integer)(struct tp_field *field, struct perf_sample *sample);
 256		void *(*pointer)(struct tp_field *field, struct perf_sample *sample);
 257	};
 258};
 259
 260#define TP_UINT_FIELD(bits) \
 261static u64 tp_field__u##bits(struct tp_field *field, struct perf_sample *sample) \
 262{ \
 263	u##bits value; \
 264	memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 265	return value;  \
 266}
 267
 268TP_UINT_FIELD(8);
 269TP_UINT_FIELD(16);
 270TP_UINT_FIELD(32);
 271TP_UINT_FIELD(64);
 272
 273#define TP_UINT_FIELD__SWAPPED(bits) \
 274static u64 tp_field__swapped_u##bits(struct tp_field *field, struct perf_sample *sample) \
 275{ \
 276	u##bits value; \
 277	memcpy(&value, sample->raw_data + field->offset, sizeof(value)); \
 278	return bswap_##bits(value);\
 279}
 280
 281TP_UINT_FIELD__SWAPPED(16);
 282TP_UINT_FIELD__SWAPPED(32);
 283TP_UINT_FIELD__SWAPPED(64);
 284
 285static int __tp_field__init_uint(struct tp_field *field, int size, int offset, bool needs_swap)
 286{
 287	field->offset = offset;
 288
 289	switch (size) {
 290	case 1:
 291		field->integer = tp_field__u8;
 292		break;
 293	case 2:
 294		field->integer = needs_swap ? tp_field__swapped_u16 : tp_field__u16;
 295		break;
 296	case 4:
 297		field->integer = needs_swap ? tp_field__swapped_u32 : tp_field__u32;
 298		break;
 299	case 8:
 300		field->integer = needs_swap ? tp_field__swapped_u64 : tp_field__u64;
 301		break;
 302	default:
 303		return -1;
 304	}
 305
 306	return 0;
 307}
 308
 309static int tp_field__init_uint(struct tp_field *field, struct tep_format_field *format_field, bool needs_swap)
 310{
 311	return __tp_field__init_uint(field, format_field->size, format_field->offset, needs_swap);
 312}
 313
 314static void *tp_field__ptr(struct tp_field *field, struct perf_sample *sample)
 315{
 316	return sample->raw_data + field->offset;
 317}
 318
 319static int __tp_field__init_ptr(struct tp_field *field, int offset)
 320{
 321	field->offset = offset;
 322	field->pointer = tp_field__ptr;
 323	return 0;
 324}
 325
 326static int tp_field__init_ptr(struct tp_field *field, struct tep_format_field *format_field)
 327{
 328	return __tp_field__init_ptr(field, format_field->offset);
 329}
 330
 331struct syscall_tp {
 332	struct tp_field id;
 333	union {
 334		struct tp_field args, ret;
 335	};
 336};
 337
 338/*
 339 * The evsel->priv as used by 'perf trace'
 340 * sc:	for raw_syscalls:sys_{enter,exit} and syscalls:sys_{enter,exit}_SYSCALLNAME
 341 * fmt: for all the other tracepoints
 342 */
 343struct evsel_trace {
 344	struct syscall_tp	sc;
 345	struct syscall_arg_fmt  *fmt;
 346};
 347
 348static struct evsel_trace *evsel_trace__new(void)
 349{
 350	return zalloc(sizeof(struct evsel_trace));
 351}
 352
 353static void evsel_trace__delete(struct evsel_trace *et)
 354{
 355	if (et == NULL)
 356		return;
 357
 358	zfree(&et->fmt);
 359	free(et);
 360}
 361
 362/*
 363 * Used with raw_syscalls:sys_{enter,exit} and with the
 364 * syscalls:sys_{enter,exit}_SYSCALL tracepoints
 365 */
 366static inline struct syscall_tp *__evsel__syscall_tp(struct evsel *evsel)
 367{
 368	struct evsel_trace *et = evsel->priv;
 369
 370	return &et->sc;
 371}
 372
 373static struct syscall_tp *evsel__syscall_tp(struct evsel *evsel)
 374{
 375	if (evsel->priv == NULL) {
 376		evsel->priv = evsel_trace__new();
 377		if (evsel->priv == NULL)
 378			return NULL;
 379	}
 380
 381	return __evsel__syscall_tp(evsel);
 382}
 383
 384/*
 385 * Used with all the other tracepoints.
 386 */
 387static inline struct syscall_arg_fmt *__evsel__syscall_arg_fmt(struct evsel *evsel)
 388{
 389	struct evsel_trace *et = evsel->priv;
 390
 391	return et->fmt;
 392}
 393
 394static struct syscall_arg_fmt *evsel__syscall_arg_fmt(struct evsel *evsel)
 395{
 396	struct evsel_trace *et = evsel->priv;
 397
 398	if (evsel->priv == NULL) {
 399		et = evsel->priv = evsel_trace__new();
 400
 401		if (et == NULL)
 402			return NULL;
 403	}
 404
 405	if (et->fmt == NULL) {
 406		const struct tep_event *tp_format = evsel__tp_format(evsel);
 407
 408		if (tp_format == NULL)
 409			goto out_delete;
 410
 411		et->fmt = calloc(tp_format->format.nr_fields, sizeof(struct syscall_arg_fmt));
 412		if (et->fmt == NULL)
 413			goto out_delete;
 414	}
 415
 416	return __evsel__syscall_arg_fmt(evsel);
 417
 418out_delete:
 419	evsel_trace__delete(evsel->priv);
 420	evsel->priv = NULL;
 421	return NULL;
 422}
 423
 424static int evsel__init_tp_uint_field(struct evsel *evsel, struct tp_field *field, const char *name)
 425{
 426	struct tep_format_field *format_field = evsel__field(evsel, name);
 427
 428	if (format_field == NULL)
 429		return -1;
 430
 431	return tp_field__init_uint(field, format_field, evsel->needs_swap);
 432}
 433
 434#define perf_evsel__init_sc_tp_uint_field(evsel, name) \
 435	({ struct syscall_tp *sc = __evsel__syscall_tp(evsel);\
 436	   evsel__init_tp_uint_field(evsel, &sc->name, #name); })
 437
 438static int evsel__init_tp_ptr_field(struct evsel *evsel, struct tp_field *field, const char *name)
 439{
 440	struct tep_format_field *format_field = evsel__field(evsel, name);
 441
 442	if (format_field == NULL)
 443		return -1;
 444
 445	return tp_field__init_ptr(field, format_field);
 446}
 447
 448#define perf_evsel__init_sc_tp_ptr_field(evsel, name) \
 449	({ struct syscall_tp *sc = __evsel__syscall_tp(evsel);\
 450	   evsel__init_tp_ptr_field(evsel, &sc->name, #name); })
 451
 452static void evsel__delete_priv(struct evsel *evsel)
 453{
 454	zfree(&evsel->priv);
 455	evsel__delete(evsel);
 456}
 457
 458static int evsel__init_syscall_tp(struct evsel *evsel)
 459{
 460	struct syscall_tp *sc = evsel__syscall_tp(evsel);
 461
 462	if (sc != NULL) {
 463		if (evsel__init_tp_uint_field(evsel, &sc->id, "__syscall_nr") &&
 464		    evsel__init_tp_uint_field(evsel, &sc->id, "nr"))
 465			return -ENOENT;
 466
 467		return 0;
 468	}
 469
 470	return -ENOMEM;
 471}
 472
 473static int evsel__init_augmented_syscall_tp(struct evsel *evsel, struct evsel *tp)
 474{
 475	struct syscall_tp *sc = evsel__syscall_tp(evsel);
 476
 477	if (sc != NULL) {
 478		struct tep_format_field *syscall_id = evsel__field(tp, "id");
 479		if (syscall_id == NULL)
 480			syscall_id = evsel__field(tp, "__syscall_nr");
 481		if (syscall_id == NULL ||
 482		    __tp_field__init_uint(&sc->id, syscall_id->size, syscall_id->offset, evsel->needs_swap))
 483			return -EINVAL;
 484
 485		return 0;
 486	}
 487
 488	return -ENOMEM;
 489}
 490
 491static int evsel__init_augmented_syscall_tp_args(struct evsel *evsel)
 492{
 493	struct syscall_tp *sc = __evsel__syscall_tp(evsel);
 494
 495	return __tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64));
 496}
 497
 498static int evsel__init_augmented_syscall_tp_ret(struct evsel *evsel)
 499{
 500	struct syscall_tp *sc = __evsel__syscall_tp(evsel);
 501
 502	return __tp_field__init_uint(&sc->ret, sizeof(u64), sc->id.offset + sizeof(u64), evsel->needs_swap);
 503}
 504
 505static int evsel__init_raw_syscall_tp(struct evsel *evsel, void *handler)
 506{
 507	if (evsel__syscall_tp(evsel) != NULL) {
 508		if (perf_evsel__init_sc_tp_uint_field(evsel, id))
 509			return -ENOENT;
 510
 511		evsel->handler = handler;
 512		return 0;
 513	}
 514
 515	return -ENOMEM;
 516}
 517
 518static struct evsel *perf_evsel__raw_syscall_newtp(const char *direction, void *handler)
 519{
 520	struct evsel *evsel = evsel__newtp("raw_syscalls", direction);
 521
 522	/* older kernel (e.g., RHEL6) use syscalls:{enter,exit} */
 523	if (IS_ERR(evsel))
 524		evsel = evsel__newtp("syscalls", direction);
 525
 526	if (IS_ERR(evsel))
 527		return NULL;
 528
 529	if (evsel__init_raw_syscall_tp(evsel, handler))
 530		goto out_delete;
 531
 532	return evsel;
 533
 534out_delete:
 535	evsel__delete_priv(evsel);
 536	return NULL;
 537}
 538
 539#define perf_evsel__sc_tp_uint(evsel, name, sample) \
 540	({ struct syscall_tp *fields = __evsel__syscall_tp(evsel); \
 541	   fields->name.integer(&fields->name, sample); })
 542
 543#define perf_evsel__sc_tp_ptr(evsel, name, sample) \
 544	({ struct syscall_tp *fields = __evsel__syscall_tp(evsel); \
 545	   fields->name.pointer(&fields->name, sample); })
 546
 547size_t strarray__scnprintf_suffix(struct strarray *sa, char *bf, size_t size, const char *intfmt, bool show_suffix, int val)
 548{
 549	int idx = val - sa->offset;
 550
 551	if (idx < 0 || idx >= sa->nr_entries || sa->entries[idx] == NULL) {
 552		size_t printed = scnprintf(bf, size, intfmt, val);
 553		if (show_suffix)
 554			printed += scnprintf(bf + printed, size - printed, " /* %s??? */", sa->prefix);
 555		return printed;
 556	}
 557
 558	return scnprintf(bf, size, "%s%s", sa->entries[idx], show_suffix ? sa->prefix : "");
 559}
 560
 561size_t strarray__scnprintf(struct strarray *sa, char *bf, size_t size, const char *intfmt, bool show_prefix, int val)
 562{
 563	int idx = val - sa->offset;
 564
 565	if (idx < 0 || idx >= sa->nr_entries || sa->entries[idx] == NULL) {
 566		size_t printed = scnprintf(bf, size, intfmt, val);
 567		if (show_prefix)
 568			printed += scnprintf(bf + printed, size - printed, " /* %s??? */", sa->prefix);
 569		return printed;
 570	}
 571
 572	return scnprintf(bf, size, "%s%s", show_prefix ? sa->prefix : "", sa->entries[idx]);
 573}
 574
 575static size_t __syscall_arg__scnprintf_strarray(char *bf, size_t size,
 576						const char *intfmt,
 577					        struct syscall_arg *arg)
 578{
 579	return strarray__scnprintf(arg->parm, bf, size, intfmt, arg->show_string_prefix, arg->val);
 580}
 581
 582static size_t syscall_arg__scnprintf_strarray(char *bf, size_t size,
 583					      struct syscall_arg *arg)
 584{
 585	return __syscall_arg__scnprintf_strarray(bf, size, "%d", arg);
 586}
 587
 588#define SCA_STRARRAY syscall_arg__scnprintf_strarray
 589
 590bool syscall_arg__strtoul_strarray(char *bf, size_t size, struct syscall_arg *arg, u64 *ret)
 591{
 592	return strarray__strtoul(arg->parm, bf, size, ret);
 593}
 594
 595bool syscall_arg__strtoul_strarray_flags(char *bf, size_t size, struct syscall_arg *arg, u64 *ret)
 596{
 597	return strarray__strtoul_flags(arg->parm, bf, size, ret);
 598}
 599
 600bool syscall_arg__strtoul_strarrays(char *bf, size_t size, struct syscall_arg *arg, u64 *ret)
 601{
 602	return strarrays__strtoul(arg->parm, bf, size, ret);
 603}
 604
 605size_t syscall_arg__scnprintf_strarray_flags(char *bf, size_t size, struct syscall_arg *arg)
 606{
 607	return strarray__scnprintf_flags(arg->parm, bf, size, arg->show_string_prefix, arg->val);
 608}
 609
 610size_t strarrays__scnprintf(struct strarrays *sas, char *bf, size_t size, const char *intfmt, bool show_prefix, int val)
 611{
 612	size_t printed;
 613	int i;
 614
 615	for (i = 0; i < sas->nr_entries; ++i) {
 616		struct strarray *sa = sas->entries[i];
 617		int idx = val - sa->offset;
 618
 619		if (idx >= 0 && idx < sa->nr_entries) {
 620			if (sa->entries[idx] == NULL)
 621				break;
 622			return scnprintf(bf, size, "%s%s", show_prefix ? sa->prefix : "", sa->entries[idx]);
 623		}
 624	}
 625
 626	printed = scnprintf(bf, size, intfmt, val);
 627	if (show_prefix)
 628		printed += scnprintf(bf + printed, size - printed, " /* %s??? */", sas->entries[0]->prefix);
 629	return printed;
 630}
 631
 632bool strarray__strtoul(struct strarray *sa, char *bf, size_t size, u64 *ret)
 633{
 634	int i;
 635
 636	for (i = 0; i < sa->nr_entries; ++i) {
 637		if (sa->entries[i] && strncmp(sa->entries[i], bf, size) == 0 && sa->entries[i][size] == '\0') {
 638			*ret = sa->offset + i;
 639			return true;
 640		}
 641	}
 642
 643	return false;
 644}
 645
 646bool strarray__strtoul_flags(struct strarray *sa, char *bf, size_t size, u64 *ret)
 647{
 648	u64 val = 0;
 649	char *tok = bf, *sep, *end;
 650
 651	*ret = 0;
 652
 653	while (size != 0) {
 654		int toklen = size;
 655
 656		sep = memchr(tok, '|', size);
 657		if (sep != NULL) {
 658			size -= sep - tok + 1;
 659
 660			end = sep - 1;
 661			while (end > tok && isspace(*end))
 662				--end;
 663
 664			toklen = end - tok + 1;
 665		}
 666
 667		while (isspace(*tok))
 668			++tok;
 669
 670		if (isalpha(*tok) || *tok == '_') {
 671			if (!strarray__strtoul(sa, tok, toklen, &val))
 672				return false;
 673		} else
 674			val = strtoul(tok, NULL, 0);
 675
 676		*ret |= (1 << (val - 1));
 677
 678		if (sep == NULL)
 679			break;
 680		tok = sep + 1;
 681	}
 682
 683	return true;
 684}
 685
 686bool strarrays__strtoul(struct strarrays *sas, char *bf, size_t size, u64 *ret)
 687{
 688	int i;
 689
 690	for (i = 0; i < sas->nr_entries; ++i) {
 691		struct strarray *sa = sas->entries[i];
 692
 693		if (strarray__strtoul(sa, bf, size, ret))
 694			return true;
 695	}
 696
 697	return false;
 698}
 699
 700size_t syscall_arg__scnprintf_strarrays(char *bf, size_t size,
 701					struct syscall_arg *arg)
 702{
 703	return strarrays__scnprintf(arg->parm, bf, size, "%d", arg->show_string_prefix, arg->val);
 704}
 705
 706#ifndef AT_FDCWD
 707#define AT_FDCWD	-100
 708#endif
 709
 710static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
 711					   struct syscall_arg *arg)
 712{
 713	int fd = arg->val;
 714	const char *prefix = "AT_FD";
 715
 716	if (fd == AT_FDCWD)
 717		return scnprintf(bf, size, "%s%s", arg->show_string_prefix ? prefix : "", "CWD");
 718
 719	return syscall_arg__scnprintf_fd(bf, size, arg);
 720}
 721
 722#define SCA_FDAT syscall_arg__scnprintf_fd_at
 723
 724static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
 725					      struct syscall_arg *arg);
 726
 727#define SCA_CLOSE_FD syscall_arg__scnprintf_close_fd
 728
 729size_t syscall_arg__scnprintf_hex(char *bf, size_t size, struct syscall_arg *arg)
 730{
 731	return scnprintf(bf, size, "%#lx", arg->val);
 732}
 733
 734size_t syscall_arg__scnprintf_ptr(char *bf, size_t size, struct syscall_arg *arg)
 735{
 736	if (arg->val == 0)
 737		return scnprintf(bf, size, "NULL");
 738	return syscall_arg__scnprintf_hex(bf, size, arg);
 739}
 740
 741size_t syscall_arg__scnprintf_int(char *bf, size_t size, struct syscall_arg *arg)
 742{
 743	return scnprintf(bf, size, "%d", arg->val);
 744}
 745
 746size_t syscall_arg__scnprintf_long(char *bf, size_t size, struct syscall_arg *arg)
 747{
 748	return scnprintf(bf, size, "%ld", arg->val);
 749}
 750
 751static size_t syscall_arg__scnprintf_char_array(char *bf, size_t size, struct syscall_arg *arg)
 752{
 753	// XXX Hey, maybe for sched:sched_switch prev/next comm fields we can
 754	//     fill missing comms using thread__set_comm()...
 755	//     here or in a special syscall_arg__scnprintf_pid_sched_tp...
 756	return scnprintf(bf, size, "\"%-.*s\"", arg->fmt->nr_entries ?: arg->len, arg->val);
 757}
 758
 759#define SCA_CHAR_ARRAY syscall_arg__scnprintf_char_array
 760
 761static const char *bpf_cmd[] = {
 762	"MAP_CREATE", "MAP_LOOKUP_ELEM", "MAP_UPDATE_ELEM", "MAP_DELETE_ELEM",
 763	"MAP_GET_NEXT_KEY", "PROG_LOAD", "OBJ_PIN", "OBJ_GET", "PROG_ATTACH",
 764	"PROG_DETACH", "PROG_TEST_RUN", "PROG_GET_NEXT_ID", "MAP_GET_NEXT_ID",
 765	"PROG_GET_FD_BY_ID", "MAP_GET_FD_BY_ID", "OBJ_GET_INFO_BY_FD",
 766	"PROG_QUERY", "RAW_TRACEPOINT_OPEN", "BTF_LOAD", "BTF_GET_FD_BY_ID",
 767	"TASK_FD_QUERY", "MAP_LOOKUP_AND_DELETE_ELEM", "MAP_FREEZE",
 768	"BTF_GET_NEXT_ID", "MAP_LOOKUP_BATCH", "MAP_LOOKUP_AND_DELETE_BATCH",
 769	"MAP_UPDATE_BATCH", "MAP_DELETE_BATCH", "LINK_CREATE", "LINK_UPDATE",
 770	"LINK_GET_FD_BY_ID", "LINK_GET_NEXT_ID", "ENABLE_STATS", "ITER_CREATE",
 771	"LINK_DETACH", "PROG_BIND_MAP",
 772};
 773static DEFINE_STRARRAY(bpf_cmd, "BPF_");
 774
 775static const char *fsmount_flags[] = {
 776	[1] = "CLOEXEC",
 777};
 778static DEFINE_STRARRAY(fsmount_flags, "FSMOUNT_");
 779
 780#include "trace/beauty/generated/fsconfig_arrays.c"
 781
 782static DEFINE_STRARRAY(fsconfig_cmds, "FSCONFIG_");
 783
 784static const char *epoll_ctl_ops[] = { "ADD", "DEL", "MOD", };
 785static DEFINE_STRARRAY_OFFSET(epoll_ctl_ops, "EPOLL_CTL_", 1);
 786
 787static const char *itimers[] = { "REAL", "VIRTUAL", "PROF", };
 788static DEFINE_STRARRAY(itimers, "ITIMER_");
 789
 790static const char *keyctl_options[] = {
 791	"GET_KEYRING_ID", "JOIN_SESSION_KEYRING", "UPDATE", "REVOKE", "CHOWN",
 792	"SETPERM", "DESCRIBE", "CLEAR", "LINK", "UNLINK", "SEARCH", "READ",
 793	"INSTANTIATE", "NEGATE", "SET_REQKEY_KEYRING", "SET_TIMEOUT",
 794	"ASSUME_AUTHORITY", "GET_SECURITY", "SESSION_TO_PARENT", "REJECT",
 795	"INSTANTIATE_IOV", "INVALIDATE", "GET_PERSISTENT",
 796};
 797static DEFINE_STRARRAY(keyctl_options, "KEYCTL_");
 798
 799static const char *whences[] = { "SET", "CUR", "END",
 800#ifdef SEEK_DATA
 801"DATA",
 802#endif
 803#ifdef SEEK_HOLE
 804"HOLE",
 805#endif
 806};
 807static DEFINE_STRARRAY(whences, "SEEK_");
 808
 809static const char *fcntl_cmds[] = {
 810	"DUPFD", "GETFD", "SETFD", "GETFL", "SETFL", "GETLK", "SETLK",
 811	"SETLKW", "SETOWN", "GETOWN", "SETSIG", "GETSIG", "GETLK64",
 812	"SETLK64", "SETLKW64", "SETOWN_EX", "GETOWN_EX",
 813	"GETOWNER_UIDS",
 814};
 815static DEFINE_STRARRAY(fcntl_cmds, "F_");
 816
 817static const char *fcntl_linux_specific_cmds[] = {
 818	"SETLEASE", "GETLEASE", "NOTIFY", "DUPFD_QUERY", [5] = "CANCELLK", "DUPFD_CLOEXEC",
 819	"SETPIPE_SZ", "GETPIPE_SZ", "ADD_SEALS", "GET_SEALS",
 820	"GET_RW_HINT", "SET_RW_HINT", "GET_FILE_RW_HINT", "SET_FILE_RW_HINT",
 821};
 822
 823static DEFINE_STRARRAY_OFFSET(fcntl_linux_specific_cmds, "F_", F_LINUX_SPECIFIC_BASE);
 824
 825static struct strarray *fcntl_cmds_arrays[] = {
 826	&strarray__fcntl_cmds,
 827	&strarray__fcntl_linux_specific_cmds,
 828};
 829
 830static DEFINE_STRARRAYS(fcntl_cmds_arrays);
 831
 832static const char *rlimit_resources[] = {
 833	"CPU", "FSIZE", "DATA", "STACK", "CORE", "RSS", "NPROC", "NOFILE",
 834	"MEMLOCK", "AS", "LOCKS", "SIGPENDING", "MSGQUEUE", "NICE", "RTPRIO",
 835	"RTTIME",
 836};
 837static DEFINE_STRARRAY(rlimit_resources, "RLIMIT_");
 838
 839static const char *sighow[] = { "BLOCK", "UNBLOCK", "SETMASK", };
 840static DEFINE_STRARRAY(sighow, "SIG_");
 841
 842static const char *clockid[] = {
 843	"REALTIME", "MONOTONIC", "PROCESS_CPUTIME_ID", "THREAD_CPUTIME_ID",
 844	"MONOTONIC_RAW", "REALTIME_COARSE", "MONOTONIC_COARSE", "BOOTTIME",
 845	"REALTIME_ALARM", "BOOTTIME_ALARM", "SGI_CYCLE", "TAI"
 846};
 847static DEFINE_STRARRAY(clockid, "CLOCK_");
 848
 849static size_t syscall_arg__scnprintf_access_mode(char *bf, size_t size,
 850						 struct syscall_arg *arg)
 851{
 852	bool show_prefix = arg->show_string_prefix;
 853	const char *suffix = "_OK";
 854	size_t printed = 0;
 855	int mode = arg->val;
 856
 857	if (mode == F_OK) /* 0 */
 858		return scnprintf(bf, size, "F%s", show_prefix ? suffix : "");
 859#define	P_MODE(n) \
 860	if (mode & n##_OK) { \
 861		printed += scnprintf(bf + printed, size - printed, "%s%s", #n, show_prefix ? suffix : ""); \
 862		mode &= ~n##_OK; \
 863	}
 864
 865	P_MODE(R);
 866	P_MODE(W);
 867	P_MODE(X);
 868#undef P_MODE
 869
 870	if (mode)
 871		printed += scnprintf(bf + printed, size - printed, "|%#x", mode);
 872
 873	return printed;
 874}
 875
 876#define SCA_ACCMODE syscall_arg__scnprintf_access_mode
 877
 878static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
 879					      struct syscall_arg *arg);
 880
 881#define SCA_FILENAME syscall_arg__scnprintf_filename
 882
 883// 'argname' is just documentational at this point, to remove the previous comment with that info
 884#define SCA_FILENAME_FROM_USER(argname) \
 885	  { .scnprintf	= SCA_FILENAME, \
 886	    .from_user	= true, }
 887
 888static size_t syscall_arg__scnprintf_buf(char *bf, size_t size, struct syscall_arg *arg);
 889
 890#define SCA_BUF syscall_arg__scnprintf_buf
 891
 892static size_t syscall_arg__scnprintf_pipe_flags(char *bf, size_t size,
 893						struct syscall_arg *arg)
 894{
 895	bool show_prefix = arg->show_string_prefix;
 896	const char *prefix = "O_";
 897	int printed = 0, flags = arg->val;
 898
 899#define	P_FLAG(n) \
 900	if (flags & O_##n) { \
 901		printed += scnprintf(bf + printed, size - printed, "%s%s%s", printed ? "|" : "", show_prefix ? prefix : "", #n); \
 902		flags &= ~O_##n; \
 903	}
 904
 905	P_FLAG(CLOEXEC);
 906	P_FLAG(NONBLOCK);
 907#undef P_FLAG
 908
 909	if (flags)
 910		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 911
 912	return printed;
 913}
 914
 915#define SCA_PIPE_FLAGS syscall_arg__scnprintf_pipe_flags
 916
 917#ifndef GRND_NONBLOCK
 918#define GRND_NONBLOCK	0x0001
 919#endif
 920#ifndef GRND_RANDOM
 921#define GRND_RANDOM	0x0002
 922#endif
 923
 924static size_t syscall_arg__scnprintf_getrandom_flags(char *bf, size_t size,
 925						   struct syscall_arg *arg)
 926{
 927	bool show_prefix = arg->show_string_prefix;
 928	const char *prefix = "GRND_";
 929	int printed = 0, flags = arg->val;
 930
 931#define	P_FLAG(n) \
 932	if (flags & GRND_##n) { \
 933		printed += scnprintf(bf + printed, size - printed, "%s%s%s", printed ? "|" : "", show_prefix ? prefix : "", #n); \
 934		flags &= ~GRND_##n; \
 935	}
 936
 937	P_FLAG(RANDOM);
 938	P_FLAG(NONBLOCK);
 939#undef P_FLAG
 940
 941	if (flags)
 942		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 943
 944	return printed;
 945}
 946
 947#define SCA_GETRANDOM_FLAGS syscall_arg__scnprintf_getrandom_flags
 948
 949#ifdef HAVE_LIBBPF_SUPPORT
 950static void syscall_arg_fmt__cache_btf_enum(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)
 951{
 952	int id;
 953
 954	type = strstr(type, "enum ");
 955	if (type == NULL)
 956		return;
 957
 958	type += 5; // skip "enum " to get the enumeration name
 959
 960	id = btf__find_by_name(btf, type);
 961	if (id < 0)
 962		return;
 963
 964	arg_fmt->type = btf__type_by_id(btf, id);
 965}
 966
 967static bool syscall_arg__strtoul_btf_enum(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
 968{
 969	const struct btf_type *bt = arg->fmt->type;
 970	struct btf *btf = arg->trace->btf;
 971	struct btf_enum *be = btf_enum(bt);
 972
 973	for (int i = 0; i < btf_vlen(bt); ++i, ++be) {
 974		const char *name = btf__name_by_offset(btf, be->name_off);
 975		int max_len = max(size, strlen(name));
 976
 977		if (strncmp(name, bf, max_len) == 0) {
 978			*val = be->val;
 979			return true;
 980		}
 981	}
 982
 983	return false;
 984}
 985
 986static bool syscall_arg__strtoul_btf_type(char *bf, size_t size, struct syscall_arg *arg, u64 *val)
 987{
 988	const struct btf_type *bt;
 989	char *type = arg->type_name;
 990	struct btf *btf;
 991
 992	trace__load_vmlinux_btf(arg->trace);
 993
 994	btf = arg->trace->btf;
 995	if (btf == NULL)
 996		return false;
 997
 998	if (arg->fmt->type == NULL) {
 999		// See if this is an enum
1000		syscall_arg_fmt__cache_btf_enum(arg->fmt, btf, type);
1001	}
1002
1003	// Now let's see if we have a BTF type resolved
1004	bt = arg->fmt->type;
1005	if (bt == NULL)
1006		return false;
1007
1008	// If it is an enum:
1009	if (btf_is_enum(arg->fmt->type))
1010		return syscall_arg__strtoul_btf_enum(bf, size, arg, val);
1011
1012	return false;
1013}
1014
1015static size_t btf_enum_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, int val)
1016{
1017	struct btf_enum *be = btf_enum(type);
1018	const int nr_entries = btf_vlen(type);
1019
1020	for (int i = 0; i < nr_entries; ++i, ++be) {
1021		if (be->val == val) {
1022			return scnprintf(bf, size, "%s",
1023					 btf__name_by_offset(btf, be->name_off));
1024		}
1025	}
1026
1027	return 0;
1028}
1029
1030struct trace_btf_dump_snprintf_ctx {
1031	char   *bf;
1032	size_t printed, size;
1033};
1034
1035static void trace__btf_dump_snprintf(void *vctx, const char *fmt, va_list args)
1036{
1037	struct trace_btf_dump_snprintf_ctx *ctx = vctx;
1038
1039	ctx->printed += vscnprintf(ctx->bf + ctx->printed, ctx->size - ctx->printed, fmt, args);
1040}
1041
1042static size_t btf_struct_scnprintf(const struct btf_type *type, struct btf *btf, char *bf, size_t size, struct syscall_arg *arg)
1043{
1044	struct trace_btf_dump_snprintf_ctx ctx = {
1045		.bf   = bf,
1046		.size = size,
1047	};
1048	struct augmented_arg *augmented_arg = arg->augmented.args;
1049	int type_id = arg->fmt->type_id, consumed;
1050	struct btf_dump *btf_dump;
1051
1052	LIBBPF_OPTS(btf_dump_opts, dump_opts);
1053	LIBBPF_OPTS(btf_dump_type_data_opts, dump_data_opts);
1054
1055	if (arg == NULL || arg->augmented.args == NULL)
1056		return 0;
1057
1058	dump_data_opts.compact	  = true;
1059	dump_data_opts.skip_names = !arg->trace->show_arg_names;
1060
1061	btf_dump = btf_dump__new(btf, trace__btf_dump_snprintf, &ctx, &dump_opts);
1062	if (btf_dump == NULL)
1063		return 0;
1064
1065	/* pretty print the struct data here */
1066	if (btf_dump__dump_type_data(btf_dump, type_id, arg->augmented.args->value, type->size, &dump_data_opts) == 0)
1067		return 0;
1068
1069	consumed = sizeof(*augmented_arg) + augmented_arg->size;
1070	arg->augmented.args = ((void *)arg->augmented.args) + consumed;
1071	arg->augmented.size -= consumed;
1072
1073	btf_dump__free(btf_dump);
1074
1075	return ctx.printed;
1076}
1077
1078static size_t trace__btf_scnprintf(struct trace *trace, struct syscall_arg *arg, char *bf,
1079				   size_t size, int val, char *type)
1080{
1081	struct syscall_arg_fmt *arg_fmt = arg->fmt;
1082
1083	if (trace->btf == NULL)
1084		return 0;
1085
1086	if (arg_fmt->type == NULL) {
1087		// Check if this is an enum and if we have the BTF type for it.
1088		syscall_arg_fmt__cache_btf_enum(arg_fmt, trace->btf, type);
1089	}
1090
1091	// Did we manage to find a BTF type for the syscall/tracepoint argument?
1092	if (arg_fmt->type == NULL)
1093		return 0;
1094
1095	if (btf_is_enum(arg_fmt->type))
1096		return btf_enum_scnprintf(arg_fmt->type, trace->btf, bf, size, val);
1097	else if (btf_is_struct(arg_fmt->type) || btf_is_union(arg_fmt->type))
1098		return btf_struct_scnprintf(arg_fmt->type, trace->btf, bf, size, arg);
1099
1100	return 0;
1101}
1102
1103#else // HAVE_LIBBPF_SUPPORT
1104static size_t trace__btf_scnprintf(struct trace *trace __maybe_unused, struct syscall_arg *arg __maybe_unused,
1105				   char *bf __maybe_unused, size_t size __maybe_unused, int val __maybe_unused,
1106				   char *type __maybe_unused)
1107{
1108	return 0;
1109}
1110
1111static bool syscall_arg__strtoul_btf_type(char *bf __maybe_unused, size_t size __maybe_unused,
1112					  struct syscall_arg *arg __maybe_unused, u64 *val __maybe_unused)
1113{
1114	return false;
1115}
1116#endif // HAVE_LIBBPF_SUPPORT
1117
1118#define STUL_BTF_TYPE syscall_arg__strtoul_btf_type
1119
1120#define STRARRAY(name, array) \
1121	  { .scnprintf	= SCA_STRARRAY, \
1122	    .strtoul	= STUL_STRARRAY, \
1123	    .parm	= &strarray__##array, \
1124	    .show_zero	= true, }
1125
1126#define STRARRAY_FLAGS(name, array) \
1127	  { .scnprintf	= SCA_STRARRAY_FLAGS, \
1128	    .strtoul	= STUL_STRARRAY_FLAGS, \
1129	    .parm	= &strarray__##array, \
1130	    .show_zero	= true, }
1131
1132#include "trace/beauty/eventfd.c"
1133#include "trace/beauty/futex_op.c"
1134#include "trace/beauty/futex_val3.c"
1135#include "trace/beauty/mmap.c"
1136#include "trace/beauty/mode_t.c"
1137#include "trace/beauty/msg_flags.c"
1138#include "trace/beauty/open_flags.c"
1139#include "trace/beauty/perf_event_open.c"
1140#include "trace/beauty/pid.c"
1141#include "trace/beauty/sched_policy.c"
1142#include "trace/beauty/seccomp.c"
1143#include "trace/beauty/signum.c"
1144#include "trace/beauty/socket_type.c"
1145#include "trace/beauty/waitid_options.c"
1146
1147static const struct syscall_fmt syscall_fmts[] = {
1148	{ .name	    = "access",
1149	  .arg = { [1] = { .scnprintf = SCA_ACCMODE,  /* mode */ }, }, },
1150	{ .name	    = "arch_prctl",
1151	  .arg = { [0] = { .scnprintf = SCA_X86_ARCH_PRCTL_CODE, /* code */ },
1152		   [1] = { .scnprintf = SCA_PTR, /* arg2 */ }, }, },
1153	{ .name	    = "bind",
1154	  .arg = { [0] = { .scnprintf = SCA_INT, /* fd */ },
1155		   [1] = SCA_SOCKADDR_FROM_USER(umyaddr),
1156		   [2] = { .scnprintf = SCA_INT, /* addrlen */ }, }, },
1157	{ .name	    = "bpf",
1158	  .arg = { [0] = STRARRAY(cmd, bpf_cmd),
1159		   [1] = { .from_user = true /* attr */, }, } },
1160	{ .name	    = "brk",	    .hexret = true,
1161	  .arg = { [0] = { .scnprintf = SCA_PTR, /* brk */ }, }, },
1162	{ .name     = "clock_gettime",
1163	  .arg = { [0] = STRARRAY(clk_id, clockid), }, },
1164	{ .name	    = "clock_nanosleep",
1165	  .arg = { [2] = SCA_TIMESPEC_FROM_USER(req), }, },
1166	{ .name	    = "clone",	    .errpid = true, .nr_args = 5,
1167	  .arg = { [0] = { .name = "flags",	    .scnprintf = SCA_CLONE_FLAGS, },
1168		   [1] = { .name = "child_stack",   .scnprintf = SCA_HEX, },
1169		   [2] = { .name = "parent_tidptr", .scnprintf = SCA_HEX, },
1170		   [3] = { .name = "child_tidptr",  .scnprintf = SCA_HEX, },
1171		   [4] = { .name = "tls",	    .scnprintf = SCA_HEX, }, }, },
1172	{ .name	    = "close",
1173	  .arg = { [0] = { .scnprintf = SCA_CLOSE_FD, /* fd */ }, }, },
1174	{ .name	    = "connect",
1175	  .arg = { [0] = { .scnprintf = SCA_INT, /* fd */ },
1176		   [1] = SCA_SOCKADDR_FROM_USER(servaddr),
1177		   [2] = { .scnprintf = SCA_INT, /* addrlen */ }, }, },
1178	{ .name	    = "epoll_ctl",
1179	  .arg = { [1] = STRARRAY(op, epoll_ctl_ops), }, },
1180	{ .name	    = "eventfd2",
1181	  .arg = { [1] = { .scnprintf = SCA_EFD_FLAGS, /* flags */ }, }, },
1182	{ .name     = "faccessat",
1183	  .arg = { [0] = { .scnprintf = SCA_FDAT,	  /* dirfd */ },
1184		   [1] = SCA_FILENAME_FROM_USER(pathname),
1185		   [2] = { .scnprintf = SCA_ACCMODE,	  /* mode */ }, }, },
1186	{ .name     = "faccessat2",
1187	  .arg = { [0] = { .scnprintf = SCA_FDAT,	  /* dirfd */ },
1188		   [1] = SCA_FILENAME_FROM_USER(pathname),
1189		   [2] = { .scnprintf = SCA_ACCMODE,	  /* mode */ },
1190		   [3] = { .scnprintf = SCA_FACCESSAT2_FLAGS, /* flags */ }, }, },
1191	{ .name	    = "fchmodat",
1192	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1193	{ .name	    = "fchownat",
1194	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1195	{ .name	    = "fcntl",
1196	  .arg = { [1] = { .scnprintf = SCA_FCNTL_CMD,  /* cmd */
1197			   .strtoul   = STUL_STRARRAYS,
1198			   .parm      = &strarrays__fcntl_cmds_arrays,
1199			   .show_zero = true, },
1200		   [2] = { .scnprintf =  SCA_FCNTL_ARG, /* arg */ }, }, },
1201	{ .name	    = "flock",
1202	  .arg = { [1] = { .scnprintf = SCA_FLOCK, /* cmd */ }, }, },
1203	{ .name     = "fsconfig",
1204	  .arg = { [1] = STRARRAY(cmd, fsconfig_cmds), }, },
1205	{ .name     = "fsmount",
1206	  .arg = { [1] = STRARRAY_FLAGS(flags, fsmount_flags),
1207		   [2] = { .scnprintf = SCA_FSMOUNT_ATTR_FLAGS, /* attr_flags */ }, }, },
1208	{ .name     = "fspick",
1209	  .arg = { [0] = { .scnprintf = SCA_FDAT,	  /* dfd */ },
1210		   [1] = SCA_FILENAME_FROM_USER(path),
1211		   [2] = { .scnprintf = SCA_FSPICK_FLAGS, /* flags */ }, }, },
1212	{ .name	    = "fstat", .alias = "newfstat", },
1213	{ .name	    = "futex",
1214	  .arg = { [1] = { .scnprintf = SCA_FUTEX_OP, /* op */ },
1215		   [5] = { .scnprintf = SCA_FUTEX_VAL3, /* val3 */ }, }, },
1216	{ .name	    = "futimesat",
1217	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1218	{ .name	    = "getitimer",
1219	  .arg = { [0] = STRARRAY(which, itimers), }, },
1220	{ .name	    = "getpid",	    .errpid = true, },
1221	{ .name	    = "getpgid",    .errpid = true, },
1222	{ .name	    = "getppid",    .errpid = true, },
1223	{ .name	    = "getrandom",
1224	  .arg = { [2] = { .scnprintf = SCA_GETRANDOM_FLAGS, /* flags */ }, }, },
1225	{ .name	    = "getrlimit",
1226	  .arg = { [0] = STRARRAY(resource, rlimit_resources), }, },
1227	{ .name	    = "getsockopt",
1228	  .arg = { [1] = STRARRAY(level, socket_level), }, },
1229	{ .name	    = "gettid",	    .errpid = true, },
1230	{ .name	    = "ioctl",
1231	  .arg = {
1232#if defined(__i386__) || defined(__x86_64__)
1233/*
1234 * FIXME: Make this available to all arches.
1235 */
1236		   [1] = { .scnprintf = SCA_IOCTL_CMD, /* cmd */ },
1237		   [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
1238#else
1239		   [2] = { .scnprintf = SCA_HEX, /* arg */ }, }, },
1240#endif
1241	{ .name	    = "kcmp",	    .nr_args = 5,
1242	  .arg = { [0] = { .name = "pid1",	.scnprintf = SCA_PID, },
1243		   [1] = { .name = "pid2",	.scnprintf = SCA_PID, },
1244		   [2] = { .name = "type",	.scnprintf = SCA_KCMP_TYPE, },
1245		   [3] = { .name = "idx1",	.scnprintf = SCA_KCMP_IDX, },
1246		   [4] = { .name = "idx2",	.scnprintf = SCA_KCMP_IDX, }, }, },
1247	{ .name	    = "keyctl",
1248	  .arg = { [0] = STRARRAY(option, keyctl_options), }, },
1249	{ .name	    = "kill",
1250	  .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1251	{ .name	    = "linkat",
1252	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1253	{ .name	    = "lseek",
1254	  .arg = { [2] = STRARRAY(whence, whences), }, },
1255	{ .name	    = "lstat", .alias = "newlstat", },
1256	{ .name     = "madvise",
1257	  .arg = { [0] = { .scnprintf = SCA_HEX,      /* start */ },
1258		   [2] = { .scnprintf = SCA_MADV_BHV, /* behavior */ }, }, },
1259	{ .name	    = "mkdirat",
1260	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1261	{ .name	    = "mknodat",
1262	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* fd */ }, }, },
1263	{ .name	    = "mmap",	    .hexret = true,
1264/* The standard mmap maps to old_mmap on s390x */
1265#if defined(__s390x__)
1266	.alias = "old_mmap",
1267#endif
1268	  .arg = { [2] = { .scnprintf = SCA_MMAP_PROT, .show_zero = true, /* prot */ },
1269		   [3] = { .scnprintf = SCA_MMAP_FLAGS,	/* flags */
1270			   .strtoul   = STUL_STRARRAY_FLAGS,
1271			   .parm      = &strarray__mmap_flags, },
1272		   [5] = { .scnprintf = SCA_HEX,	/* offset */ }, }, },
1273	{ .name	    = "mount",
1274	  .arg = { [0] = SCA_FILENAME_FROM_USER(devname),
1275		   [3] = { .scnprintf = SCA_MOUNT_FLAGS, /* flags */
1276			   .mask_val  = SCAMV_MOUNT_FLAGS, /* flags */ }, }, },
1277	{ .name	    = "move_mount",
1278	  .arg = { [0] = { .scnprintf = SCA_FDAT,	/* from_dfd */ },
1279		   [1] = SCA_FILENAME_FROM_USER(pathname),
1280		   [2] = { .scnprintf = SCA_FDAT,	/* to_dfd */ },
1281		   [3] = SCA_FILENAME_FROM_USER(pathname),
1282		   [4] = { .scnprintf = SCA_MOVE_MOUNT_FLAGS, /* flags */ }, }, },
1283	{ .name	    = "mprotect",
1284	  .arg = { [0] = { .scnprintf = SCA_HEX,	/* start */ },
1285		   [2] = { .scnprintf = SCA_MMAP_PROT, .show_zero = true, /* prot */ }, }, },
1286	{ .name	    = "mq_unlink",
1287	  .arg = { [0] = SCA_FILENAME_FROM_USER(u_name), }, },
1288	{ .name	    = "mremap",	    .hexret = true,
1289	  .arg = { [3] = { .scnprintf = SCA_MREMAP_FLAGS, /* flags */ }, }, },
1290	{ .name	    = "name_to_handle_at",
1291	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1292	{ .name	    = "nanosleep",
1293	  .arg = { [0] = SCA_TIMESPEC_FROM_USER(req), }, },
1294	{ .name	    = "newfstatat", .alias = "fstatat",
1295	  .arg = { [0] = { .scnprintf = SCA_FDAT,	  /* dirfd */ },
1296		   [1] = SCA_FILENAME_FROM_USER(pathname),
1297		   [3] = { .scnprintf = SCA_FS_AT_FLAGS, /* flags */ }, }, },
1298	{ .name	    = "open",
1299	  .arg = { [1] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1300	{ .name	    = "open_by_handle_at",
1301	  .arg = { [0] = { .scnprintf = SCA_FDAT,	/* dfd */ },
1302		   [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1303	{ .name	    = "openat",
1304	  .arg = { [0] = { .scnprintf = SCA_FDAT,	/* dfd */ },
1305		   [2] = { .scnprintf = SCA_OPEN_FLAGS, /* flags */ }, }, },
1306	{ .name	    = "perf_event_open",
1307	  .arg = { [0] = SCA_PERF_ATTR_FROM_USER(attr),
1308		   [2] = { .scnprintf = SCA_INT,	/* cpu */ },
1309		   [3] = { .scnprintf = SCA_FD,		/* group_fd */ },
1310		   [4] = { .scnprintf = SCA_PERF_FLAGS, /* flags */ }, }, },
1311	{ .name	    = "pipe2",
1312	  .arg = { [1] = { .scnprintf = SCA_PIPE_FLAGS, /* flags */ }, }, },
1313	{ .name	    = "pkey_alloc",
1314	  .arg = { [1] = { .scnprintf = SCA_PKEY_ALLOC_ACCESS_RIGHTS,	/* access_rights */ }, }, },
1315	{ .name	    = "pkey_free",
1316	  .arg = { [0] = { .scnprintf = SCA_INT,	/* key */ }, }, },
1317	{ .name	    = "pkey_mprotect",
1318	  .arg = { [0] = { .scnprintf = SCA_HEX,	/* start */ },
1319		   [2] = { .scnprintf = SCA_MMAP_PROT, .show_zero = true, /* prot */ },
1320		   [3] = { .scnprintf = SCA_INT,	/* pkey */ }, }, },
1321	{ .name	    = "poll", .timeout = true, },
1322	{ .name	    = "ppoll", .timeout = true, },
1323	{ .name	    = "prctl",
1324	  .arg = { [0] = { .scnprintf = SCA_PRCTL_OPTION, /* option */
1325			   .strtoul   = STUL_STRARRAY,
1326			   .parm      = &strarray__prctl_options, },
1327		   [1] = { .scnprintf = SCA_PRCTL_ARG2, /* arg2 */ },
1328		   [2] = { .scnprintf = SCA_PRCTL_ARG3, /* arg3 */ }, }, },
1329	{ .name	    = "pread", .alias = "pread64", },
1330	{ .name	    = "preadv", .alias = "pread", },
1331	{ .name	    = "prlimit64",
1332	  .arg = { [1] = STRARRAY(resource, rlimit_resources),
1333		   [2] = { .from_user = true /* new_rlim */, }, }, },
1334	{ .name	    = "pwrite", .alias = "pwrite64", },
1335	{ .name	    = "readlinkat",
1336	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1337	{ .name	    = "recvfrom",
1338	  .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1339	{ .name	    = "recvmmsg",
1340	  .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1341	{ .name	    = "recvmsg",
1342	  .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1343	{ .name	    = "renameat",
1344	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* olddirfd */ },
1345		   [2] = { .scnprintf = SCA_FDAT, /* newdirfd */ }, }, },
1346	{ .name	    = "renameat2",
1347	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* olddirfd */ },
1348		   [2] = { .scnprintf = SCA_FDAT, /* newdirfd */ },
1349		   [4] = { .scnprintf = SCA_RENAMEAT2_FLAGS, /* flags */ }, }, },
1350	{ .name	    = "rseq",
1351	  .arg = { [0] = { .from_user = true /* rseq */, }, }, },
1352	{ .name	    = "rt_sigaction",
1353	  .arg = { [0] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1354	{ .name	    = "rt_sigprocmask",
1355	  .arg = { [0] = STRARRAY(how, sighow), }, },
1356	{ .name	    = "rt_sigqueueinfo",
1357	  .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1358	{ .name	    = "rt_tgsigqueueinfo",
1359	  .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1360	{ .name	    = "sched_setscheduler",
1361	  .arg = { [1] = { .scnprintf = SCA_SCHED_POLICY, /* policy */ }, }, },
1362	{ .name	    = "seccomp",
1363	  .arg = { [0] = { .scnprintf = SCA_SECCOMP_OP,	   /* op */ },
1364		   [1] = { .scnprintf = SCA_SECCOMP_FLAGS, /* flags */ }, }, },
1365	{ .name	    = "select", .timeout = true, },
1366	{ .name	    = "sendfile", .alias = "sendfile64", },
1367	{ .name	    = "sendmmsg",
1368	  .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1369	{ .name	    = "sendmsg",
1370	  .arg = { [2] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ }, }, },
1371	{ .name	    = "sendto",
1372	  .arg = { [3] = { .scnprintf = SCA_MSG_FLAGS, /* flags */ },
1373		   [4] = SCA_SOCKADDR_FROM_USER(addr), }, },
1374	{ .name	    = "set_robust_list",
1375	  .arg = { [0] = { .from_user = true /* head */, }, }, },
1376	{ .name	    = "set_tid_address", .errpid = true, },
1377	{ .name	    = "setitimer",
1378	  .arg = { [0] = STRARRAY(which, itimers), }, },
1379	{ .name	    = "setrlimit",
1380	  .arg = { [0] = STRARRAY(resource, rlimit_resources),
1381		   [1] = { .from_user = true /* rlim */, }, }, },
1382	{ .name	    = "setsockopt",
1383	  .arg = { [1] = STRARRAY(level, socket_level), }, },
1384	{ .name	    = "socket",
1385	  .arg = { [0] = STRARRAY(family, socket_families),
1386		   [1] = { .scnprintf = SCA_SK_TYPE, /* type */ },
1387		   [2] = { .scnprintf = SCA_SK_PROTO, /* protocol */ }, }, },
1388	{ .name	    = "socketpair",
1389	  .arg = { [0] = STRARRAY(family, socket_families),
1390		   [1] = { .scnprintf = SCA_SK_TYPE, /* type */ },
1391		   [2] = { .scnprintf = SCA_SK_PROTO, /* protocol */ }, }, },
1392	{ .name	    = "stat", .alias = "newstat", },
1393	{ .name	    = "statx",
1394	  .arg = { [0] = { .scnprintf = SCA_FDAT,	 /* fdat */ },
1395		   [2] = { .scnprintf = SCA_FS_AT_FLAGS, /* flags */ } ,
1396		   [3] = { .scnprintf = SCA_STATX_MASK,	 /* mask */ }, }, },
1397	{ .name	    = "swapoff",
1398	  .arg = { [0] = SCA_FILENAME_FROM_USER(specialfile), }, },
1399	{ .name	    = "swapon",
1400	  .arg = { [0] = SCA_FILENAME_FROM_USER(specialfile), }, },
1401	{ .name	    = "symlinkat",
1402	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* dfd */ }, }, },
1403	{ .name	    = "sync_file_range",
1404	  .arg = { [3] = { .scnprintf = SCA_SYNC_FILE_RANGE_FLAGS, /* flags */ }, }, },
1405	{ .name	    = "tgkill",
1406	  .arg = { [2] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1407	{ .name	    = "tkill",
1408	  .arg = { [1] = { .scnprintf = SCA_SIGNUM, /* sig */ }, }, },
1409	{ .name     = "umount2", .alias = "umount",
1410	  .arg = { [0] = SCA_FILENAME_FROM_USER(name), }, },
1411	{ .name	    = "uname", .alias = "newuname", },
1412	{ .name	    = "unlinkat",
1413	  .arg = { [0] = { .scnprintf = SCA_FDAT,	  /* dfd */ },
1414		   [1] = SCA_FILENAME_FROM_USER(pathname),
1415		   [2] = { .scnprintf = SCA_FS_AT_FLAGS,  /* flags */ }, }, },
1416	{ .name	    = "utimensat",
1417	  .arg = { [0] = { .scnprintf = SCA_FDAT, /* dirfd */ }, }, },
1418	{ .name	    = "wait4",	    .errpid = true,
1419	  .arg = { [2] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
1420	{ .name	    = "waitid",	    .errpid = true,
1421	  .arg = { [3] = { .scnprintf = SCA_WAITID_OPTIONS, /* options */ }, }, },
1422	{ .name	    = "write",
1423	  .arg = { [1] = { .scnprintf = SCA_BUF /* buf */, .from_user = true, }, }, },
1424};
1425
1426static int syscall_fmt__cmp(const void *name, const void *fmtp)
1427{
1428	const struct syscall_fmt *fmt = fmtp;
1429	return strcmp(name, fmt->name);
1430}
1431
1432static const struct syscall_fmt *__syscall_fmt__find(const struct syscall_fmt *fmts,
1433						     const int nmemb,
1434						     const char *name)
1435{
1436	return bsearch(name, fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
1437}
1438
1439static const struct syscall_fmt *syscall_fmt__find(const char *name)
1440{
1441	const int nmemb = ARRAY_SIZE(syscall_fmts);
1442	return __syscall_fmt__find(syscall_fmts, nmemb, name);
1443}
1444
1445static const struct syscall_fmt *__syscall_fmt__find_by_alias(const struct syscall_fmt *fmts,
1446							      const int nmemb, const char *alias)
1447{
1448	int i;
1449
1450	for (i = 0; i < nmemb; ++i) {
1451		if (fmts[i].alias && strcmp(fmts[i].alias, alias) == 0)
1452			return &fmts[i];
1453	}
1454
1455	return NULL;
1456}
1457
1458static const struct syscall_fmt *syscall_fmt__find_by_alias(const char *alias)
1459{
1460	const int nmemb = ARRAY_SIZE(syscall_fmts);
1461	return __syscall_fmt__find_by_alias(syscall_fmts, nmemb, alias);
1462}
1463
1464/**
1465 * struct syscall
1466 */
1467struct syscall {
1468	/** @e_machine: The ELF machine associated with the entry. */
1469	int e_machine;
1470	/** @id: id value from the tracepoint, the system call number. */
1471	int id;
1472	struct tep_event    *tp_format;
1473	int		    nr_args;
1474	/**
1475	 * @args_size: sum of the sizes of the syscall arguments, anything
1476	 * after that is augmented stuff: pathname for openat, etc.
1477	 */
1478
1479	int		    args_size;
1480	struct {
1481		struct bpf_program *sys_enter,
1482				   *sys_exit;
1483	}		    bpf_prog;
1484	/** @is_exit: is this "exit" or "exit_group"? */
1485	bool		    is_exit;
1486	/**
1487	 * @is_open: is this "open" or "openat"? To associate the fd returned in
1488	 * sys_exit with the pathname in sys_enter.
1489	 */
1490	bool		    is_open;
1491	/**
1492	 * @nonexistent: Name lookup failed. Just a hole in the syscall table,
1493	 * syscall id not allocated.
1494	 */
1495	bool		    nonexistent;
1496	bool		    use_btf;
1497	struct tep_format_field *args;
1498	const char	    *name;
1499	const struct syscall_fmt  *fmt;
1500	struct syscall_arg_fmt *arg_fmt;
1501};
1502
1503/*
1504 * We need to have this 'calculated' boolean because in some cases we really
1505 * don't know what is the duration of a syscall, for instance, when we start
1506 * a session and some threads are waiting for a syscall to finish, say 'poll',
1507 * in which case all we can do is to print "( ? ) for duration and for the
1508 * start timestamp.
1509 */
1510static size_t fprintf_duration(unsigned long t, bool calculated, FILE *fp)
1511{
1512	double duration = (double)t / NSEC_PER_MSEC;
1513	size_t printed = fprintf(fp, "(");
1514
1515	if (!calculated)
1516		printed += fprintf(fp, "         ");
1517	else if (duration >= 1.0)
1518		printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
1519	else if (duration >= 0.01)
1520		printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
1521	else
1522		printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
1523	return printed + fprintf(fp, "): ");
1524}
1525
1526/**
1527 * filename.ptr: The filename char pointer that will be vfs_getname'd
1528 * filename.entry_str_pos: Where to insert the string translated from
1529 *                         filename.ptr by the vfs_getname tracepoint/kprobe.
1530 * ret_scnprintf: syscall args may set this to a different syscall return
1531 *                formatter, for instance, fcntl may return fds, file flags, etc.
1532 */
1533struct thread_trace {
1534	u64		  entry_time;
1535	bool		  entry_pending;
1536	unsigned long	  nr_events;
1537	unsigned long	  pfmaj, pfmin;
1538	char		  *entry_str;
1539	double		  runtime_ms;
1540	size_t		  (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg);
1541        struct {
1542		unsigned long ptr;
1543		short int     entry_str_pos;
1544		bool	      pending_open;
1545		unsigned int  namelen;
1546		char	      *name;
1547	} filename;
1548	struct {
1549		int	      max;
1550		struct file   *table;
1551	} files;
1552
1553	struct hashmap *syscall_stats;
1554};
1555
1556static size_t syscall_id_hash(long key, void *ctx __maybe_unused)
1557{
1558	return key;
1559}
1560
1561static bool syscall_id_equal(long key1, long key2, void *ctx __maybe_unused)
1562{
1563	return key1 == key2;
1564}
1565
1566static struct hashmap *alloc_syscall_stats(void)
1567{
1568	return hashmap__new(syscall_id_hash, syscall_id_equal, NULL);
1569}
1570
1571static void delete_syscall_stats(struct hashmap *syscall_stats)
1572{
1573	struct hashmap_entry *pos;
1574	size_t bkt;
1575
1576	if (syscall_stats == NULL)
1577		return;
1578
1579	hashmap__for_each_entry(syscall_stats, pos, bkt)
1580		zfree(&pos->pvalue);
1581	hashmap__free(syscall_stats);
1582}
1583
1584static struct thread_trace *thread_trace__new(struct trace *trace)
1585{
1586	struct thread_trace *ttrace =  zalloc(sizeof(struct thread_trace));
1587
1588	if (ttrace) {
1589		ttrace->files.max = -1;
1590		if (trace->summary) {
1591			ttrace->syscall_stats = alloc_syscall_stats();
1592			if (IS_ERR(ttrace->syscall_stats))
1593				zfree(&ttrace);
1594		}
1595	}
1596
1597	return ttrace;
1598}
1599
1600static void thread_trace__free_files(struct thread_trace *ttrace);
1601
1602static void thread_trace__delete(void *pttrace)
1603{
1604	struct thread_trace *ttrace = pttrace;
1605
1606	if (!ttrace)
1607		return;
1608
1609	delete_syscall_stats(ttrace->syscall_stats);
1610	ttrace->syscall_stats = NULL;
1611	thread_trace__free_files(ttrace);
1612	zfree(&ttrace->entry_str);
1613	free(ttrace);
1614}
1615
1616static struct thread_trace *thread__trace(struct thread *thread, struct trace *trace)
1617{
1618	struct thread_trace *ttrace;
1619
1620	if (thread == NULL)
1621		goto fail;
1622
1623	if (thread__priv(thread) == NULL)
1624		thread__set_priv(thread, thread_trace__new(trace));
1625
1626	if (thread__priv(thread) == NULL)
1627		goto fail;
1628
1629	ttrace = thread__priv(thread);
1630	++ttrace->nr_events;
1631
1632	return ttrace;
1633fail:
1634	color_fprintf(trace->output, PERF_COLOR_RED,
1635		      "WARNING: not enough memory, dropping samples!\n");
1636	return NULL;
1637}
1638
1639
1640void syscall_arg__set_ret_scnprintf(struct syscall_arg *arg,
1641				    size_t (*ret_scnprintf)(char *bf, size_t size, struct syscall_arg *arg))
1642{
1643	struct thread_trace *ttrace = thread__priv(arg->thread);
1644
1645	ttrace->ret_scnprintf = ret_scnprintf;
1646}
1647
1648#define TRACE_PFMAJ		(1 << 0)
1649#define TRACE_PFMIN		(1 << 1)
1650
1651static const size_t trace__entry_str_size = 2048;
1652
1653static void thread_trace__free_files(struct thread_trace *ttrace)
1654{
1655	for (int i = 0; i <= ttrace->files.max; ++i) {
1656		struct file *file = ttrace->files.table + i;
1657		zfree(&file->pathname);
1658	}
1659
1660	zfree(&ttrace->files.table);
1661	ttrace->files.max  = -1;
1662}
1663
1664static struct file *thread_trace__files_entry(struct thread_trace *ttrace, int fd)
1665{
1666	if (fd < 0)
1667		return NULL;
1668
1669	if (fd > ttrace->files.max) {
1670		struct file *nfiles = realloc(ttrace->files.table, (fd + 1) * sizeof(struct file));
1671
1672		if (nfiles == NULL)
1673			return NULL;
1674
1675		if (ttrace->files.max != -1) {
1676			memset(nfiles + ttrace->files.max + 1, 0,
1677			       (fd - ttrace->files.max) * sizeof(struct file));
1678		} else {
1679			memset(nfiles, 0, (fd + 1) * sizeof(struct file));
1680		}
1681
1682		ttrace->files.table = nfiles;
1683		ttrace->files.max   = fd;
1684	}
1685
1686	return ttrace->files.table + fd;
1687}
1688
1689struct file *thread__files_entry(struct thread *thread, int fd)
1690{
1691	return thread_trace__files_entry(thread__priv(thread), fd);
1692}
1693
1694static int trace__set_fd_pathname(struct thread *thread, int fd, const char *pathname)
1695{
1696	struct thread_trace *ttrace = thread__priv(thread);
1697	struct file *file = thread_trace__files_entry(ttrace, fd);
1698
1699	if (file != NULL) {
1700		struct stat st;
1701
1702		if (stat(pathname, &st) == 0)
1703			file->dev_maj = major(st.st_rdev);
1704		file->pathname = strdup(pathname);
1705		if (file->pathname)
1706			return 0;
1707	}
1708
1709	return -1;
1710}
1711
1712static int thread__read_fd_path(struct thread *thread, int fd)
1713{
1714	char linkname[PATH_MAX], pathname[PATH_MAX];
1715	struct stat st;
1716	int ret;
1717
1718	if (thread__pid(thread) == thread__tid(thread)) {
1719		scnprintf(linkname, sizeof(linkname),
1720			  "/proc/%d/fd/%d", thread__pid(thread), fd);
1721	} else {
1722		scnprintf(linkname, sizeof(linkname),
1723			  "/proc/%d/task/%d/fd/%d",
1724			  thread__pid(thread), thread__tid(thread), fd);
1725	}
1726
1727	if (lstat(linkname, &st) < 0 || st.st_size + 1 > (off_t)sizeof(pathname))
1728		return -1;
1729
1730	ret = readlink(linkname, pathname, sizeof(pathname));
1731
1732	if (ret < 0 || ret > st.st_size)
1733		return -1;
1734
1735	pathname[ret] = '\0';
1736	return trace__set_fd_pathname(thread, fd, pathname);
1737}
1738
1739static const char *thread__fd_path(struct thread *thread, int fd,
1740				   struct trace *trace)
1741{
1742	struct thread_trace *ttrace = thread__priv(thread);
1743
1744	if (ttrace == NULL || trace->fd_path_disabled)
1745		return NULL;
1746
1747	if (fd < 0)
1748		return NULL;
1749
1750	if ((fd > ttrace->files.max || ttrace->files.table[fd].pathname == NULL)) {
1751		if (!trace->live)
1752			return NULL;
1753		++trace->stats.proc_getname;
1754		if (thread__read_fd_path(thread, fd))
1755			return NULL;
1756	}
1757
1758	return ttrace->files.table[fd].pathname;
1759}
1760
1761size_t syscall_arg__scnprintf_fd(char *bf, size_t size, struct syscall_arg *arg)
1762{
1763	int fd = arg->val;
1764	size_t printed = scnprintf(bf, size, "%d", fd);
1765	const char *path = thread__fd_path(arg->thread, fd, arg->trace);
1766
1767	if (path)
1768		printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1769
1770	return printed;
1771}
1772
1773size_t pid__scnprintf_fd(struct trace *trace, pid_t pid, int fd, char *bf, size_t size)
1774{
1775        size_t printed = scnprintf(bf, size, "%d", fd);
1776	struct thread *thread = machine__find_thread(trace->host, pid, pid);
1777
1778	if (thread) {
1779		const char *path = thread__fd_path(thread, fd, trace);
1780
1781		if (path)
1782			printed += scnprintf(bf + printed, size - printed, "<%s>", path);
1783
1784		thread__put(thread);
1785	}
1786
1787        return printed;
1788}
1789
1790static size_t syscall_arg__scnprintf_close_fd(char *bf, size_t size,
1791					      struct syscall_arg *arg)
1792{
1793	int fd = arg->val;
1794	size_t printed = syscall_arg__scnprintf_fd(bf, size, arg);
1795	struct thread_trace *ttrace = thread__priv(arg->thread);
1796
1797	if (ttrace && fd >= 0 && fd <= ttrace->files.max)
1798		zfree(&ttrace->files.table[fd].pathname);
1799
1800	return printed;
1801}
1802
1803static void thread__set_filename_pos(struct thread *thread, const char *bf,
1804				     unsigned long ptr)
1805{
1806	struct thread_trace *ttrace = thread__priv(thread);
1807
1808	ttrace->filename.ptr = ptr;
1809	ttrace->filename.entry_str_pos = bf - ttrace->entry_str;
1810}
1811
1812static size_t syscall_arg__scnprintf_augmented_string(struct syscall_arg *arg, char *bf, size_t size)
1813{
1814	struct augmented_arg *augmented_arg = arg->augmented.args;
1815	size_t printed = scnprintf(bf, size, "\"%.*s\"", augmented_arg->size, augmented_arg->value);
1816	/*
1817	 * So that the next arg with a payload can consume its augmented arg, i.e. for rename* syscalls
1818	 * we would have two strings, each prefixed by its size.
1819	 */
1820	int consumed = sizeof(*augmented_arg) + augmented_arg->size;
1821
1822	arg->augmented.args = ((void *)arg->augmented.args) + consumed;
1823	arg->augmented.size -= consumed;
1824
1825	return printed;
1826}
1827
1828static size_t syscall_arg__scnprintf_filename(char *bf, size_t size,
1829					      struct syscall_arg *arg)
1830{
1831	unsigned long ptr = arg->val;
1832
1833	if (arg->augmented.args)
1834		return syscall_arg__scnprintf_augmented_string(arg, bf, size);
1835
1836	if (!arg->trace->vfs_getname)
1837		return scnprintf(bf, size, "%#x", ptr);
1838
1839	thread__set_filename_pos(arg->thread, bf, ptr);
1840	return 0;
1841}
1842
1843#define MAX_CONTROL_CHAR 31
1844#define MAX_ASCII 127
1845
1846static size_t syscall_arg__scnprintf_buf(char *bf, size_t size, struct syscall_arg *arg)
1847{
1848	struct augmented_arg *augmented_arg = arg->augmented.args;
1849	unsigned char *orig = (unsigned char *)augmented_arg->value;
1850	size_t printed = 0;
1851	int consumed;
1852
1853	if (augmented_arg == NULL)
1854		return 0;
1855
1856	for (int j = 0; j < augmented_arg->size; ++j) {
1857		bool control_char = orig[j] <= MAX_CONTROL_CHAR || orig[j] >= MAX_ASCII;
1858		/* print control characters (0~31 and 127), and non-ascii characters in \(digits) */
1859		printed += scnprintf(bf + printed, size - printed, control_char ? "\\%d" : "%c", (int)orig[j]);
1860	}
1861
1862	consumed = sizeof(*augmented_arg) + augmented_arg->size;
1863	arg->augmented.args = ((void *)arg->augmented.args) + consumed;
1864	arg->augmented.size -= consumed;
1865
1866	return printed;
1867}
1868
1869static bool trace__filter_duration(struct trace *trace, double t)
1870{
1871	return t < (trace->duration_filter * NSEC_PER_MSEC);
1872}
1873
1874static size_t __trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1875{
1876	double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
1877
1878	return fprintf(fp, "%10.3f ", ts);
1879}
1880
1881/*
1882 * We're handling tstamp=0 as an undefined tstamp, i.e. like when we are
1883 * using ttrace->entry_time for a thread that receives a sys_exit without
1884 * first having received a sys_enter ("poll" issued before tracing session
1885 * starts, lost sys_enter exit due to ring buffer overflow).
1886 */
1887static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
1888{
1889	if (tstamp > 0)
1890		return __trace__fprintf_tstamp(trace, tstamp, fp);
1891
1892	return fprintf(fp, "         ? ");
1893}
1894
1895static pid_t workload_pid = -1;
1896static volatile sig_atomic_t done = false;
1897static volatile sig_atomic_t interrupted = false;
1898
1899static void sighandler_interrupt(int sig __maybe_unused)
1900{
1901	done = interrupted = true;
1902}
1903
1904static void sighandler_chld(int sig __maybe_unused, siginfo_t *info,
1905			    void *context __maybe_unused)
1906{
1907	if (info->si_pid == workload_pid)
1908		done = true;
1909}
1910
1911static size_t trace__fprintf_comm_tid(struct trace *trace, struct thread *thread, FILE *fp)
1912{
1913	size_t printed = 0;
1914
1915	if (trace->multiple_threads) {
1916		if (trace->show_comm)
1917			printed += fprintf(fp, "%.14s/", thread__comm_str(thread));
1918		printed += fprintf(fp, "%d ", thread__tid(thread));
1919	}
1920
1921	return printed;
1922}
1923
1924static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
1925					u64 duration, bool duration_calculated, u64 tstamp, FILE *fp)
1926{
1927	size_t printed = 0;
1928
1929	if (trace->show_tstamp)
1930		printed = trace__fprintf_tstamp(trace, tstamp, fp);
1931	if (trace->show_duration)
1932		printed += fprintf_duration(duration, duration_calculated, fp);
1933	return printed + trace__fprintf_comm_tid(trace, thread, fp);
1934}
1935
1936static int trace__process_event(struct trace *trace, struct machine *machine,
1937				union perf_event *event, struct perf_sample *sample)
1938{
1939	int ret = 0;
1940
1941	switch (event->header.type) {
1942	case PERF_RECORD_LOST:
1943		color_fprintf(trace->output, PERF_COLOR_RED,
1944			      "LOST %" PRIu64 " events!\n", (u64)event->lost.lost);
1945		ret = machine__process_lost_event(machine, event, sample);
1946		break;
1947	default:
1948		ret = machine__process_event(machine, event, sample);
1949		break;
1950	}
1951
1952	return ret;
1953}
1954
1955static int trace__tool_process(const struct perf_tool *tool,
1956			       union perf_event *event,
1957			       struct perf_sample *sample,
1958			       struct machine *machine)
1959{
1960	struct trace *trace = container_of(tool, struct trace, tool);
1961	return trace__process_event(trace, machine, event, sample);
1962}
1963
1964static char *trace__machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, char **modp)
1965{
1966	struct machine *machine = vmachine;
1967
1968	if (machine->kptr_restrict_warned)
1969		return NULL;
1970
1971	if (symbol_conf.kptr_restrict) {
1972		pr_warning("Kernel address maps (/proc/{kallsyms,modules}) are restricted.\n\n"
1973			   "Check /proc/sys/kernel/kptr_restrict and /proc/sys/kernel/perf_event_paranoid.\n\n"
1974			   "Kernel samples will not be resolved.\n");
1975		machine->kptr_restrict_warned = true;
1976		return NULL;
1977	}
1978
1979	return machine__resolve_kernel_addr(vmachine, addrp, modp);
1980}
1981
1982static int trace__symbols_init(struct trace *trace, int argc, const char **argv,
1983			       struct evlist *evlist)
1984{
1985	int err = symbol__init(NULL);
1986
1987	if (err)
1988		return err;
1989
1990	perf_env__init(&trace->host_env);
1991	err = perf_env__set_cmdline(&trace->host_env, argc, argv);
1992	if (err)
1993		goto out;
1994
1995	trace->host = machine__new_host(&trace->host_env);
1996	if (trace->host == NULL) {
1997		err = -ENOMEM;
1998		goto out;
1999	}
2000	thread__set_priv_destructor(thread_trace__delete);
2001
2002	err = trace_event__register_resolver(trace->host, trace__machine__resolve_kernel_addr);
2003	if (err < 0)
2004		goto out;
2005
2006	err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
2007					    evlist->core.threads, trace__tool_process,
2008					    /*needs_mmap=*/callchain_param.enabled,
2009					    /*mmap_data=*/false,
2010					    /*nr_threads_synthesize=*/1);
2011out:
2012	if (err) {
2013		perf_env__exit(&trace->host_env);
2014		symbol__exit();
2015	}
2016	return err;
2017}
2018
2019static void trace__symbols__exit(struct trace *trace)
2020{
2021	machine__exit(trace->host);
2022	trace->host = NULL;
2023
2024	perf_env__exit(&trace->host_env);
2025	symbol__exit();
2026}
2027
2028static int syscall__alloc_arg_fmts(struct syscall *sc, int nr_args)
2029{
2030	int idx;
2031
2032	if (nr_args == RAW_SYSCALL_ARGS_NUM && sc->fmt && sc->fmt->nr_args != 0)
2033		nr_args = sc->fmt->nr_args;
2034
2035	sc->arg_fmt = calloc(nr_args, sizeof(*sc->arg_fmt));
2036	if (sc->arg_fmt == NULL)
2037		return -1;
2038
2039	for (idx = 0; idx < nr_args; ++idx) {
2040		if (sc->fmt)
2041			sc->arg_fmt[idx] = sc->fmt->arg[idx];
2042	}
2043
2044	sc->nr_args = nr_args;
2045	return 0;
2046}
2047
2048static const struct syscall_arg_fmt syscall_arg_fmts__by_name[] = {
2049	{ .name = "msr",	.scnprintf = SCA_X86_MSR,	  .strtoul = STUL_X86_MSR,	   },
2050	{ .name = "vector",	.scnprintf = SCA_X86_IRQ_VECTORS, .strtoul = STUL_X86_IRQ_VECTORS, },
2051};
2052
2053static int syscall_arg_fmt__cmp(const void *name, const void *fmtp)
2054{
2055       const struct syscall_arg_fmt *fmt = fmtp;
2056       return strcmp(name, fmt->name);
2057}
2058
2059static const struct syscall_arg_fmt *
2060__syscall_arg_fmt__find_by_name(const struct syscall_arg_fmt *fmts, const int nmemb,
2061				const char *name)
2062{
2063       return bsearch(name, fmts, nmemb, sizeof(struct syscall_arg_fmt), syscall_arg_fmt__cmp);
2064}
2065
2066static const struct syscall_arg_fmt *syscall_arg_fmt__find_by_name(const char *name)
2067{
2068       const int nmemb = ARRAY_SIZE(syscall_arg_fmts__by_name);
2069       return __syscall_arg_fmt__find_by_name(syscall_arg_fmts__by_name, nmemb, name);
2070}
2071
2072/*
2073 * v6.19 kernel added new fields to read userspace memory for event tracing.
2074 * But it's not used by perf and confuses the syscall parameters.
2075 */
2076static bool is_internal_field(struct tep_format_field *field)
2077{
2078	return !strcmp(field->type, "__data_loc char[]");
2079}
2080
2081static struct tep_format_field *
2082syscall_arg_fmt__init_array(struct syscall_arg_fmt *arg, struct tep_format_field *field,
2083			    bool *use_btf)
2084{
2085	struct tep_format_field *last_field = NULL;
2086	int len;
2087
2088	for (; field; field = field->next, ++arg) {
2089		/* assume it's the last argument */
2090		if (is_internal_field(field))
2091			continue;
2092
2093		last_field = field;
2094
2095		if (arg->scnprintf)
2096			continue;
2097
2098		len = strlen(field->name);
2099
2100		// As far as heuristics (or intention) goes this seems to hold true, and makes sense!
2101		if ((field->flags & TEP_FIELD_IS_POINTER) && strstarts(field->type, "const "))
2102			arg->from_user = true;
2103
2104		if (strcmp(field->type, "const char *") == 0 &&
2105		    ((len >= 4 && strcmp(field->name + len - 4, "name") == 0) ||
2106		     strstr(field->name, "path") != NULL)) {
2107			arg->scnprintf = SCA_FILENAME;
2108		} else if ((field->flags & TEP_FIELD_IS_POINTER) || strstr(field->name, "addr"))
2109			arg->scnprintf = SCA_PTR;
2110		else if (strcmp(field->type, "pid_t") == 0)
2111			arg->scnprintf = SCA_PID;
2112		else if (strcmp(field->type, "umode_t") == 0)
2113			arg->scnprintf = SCA_MODE_T;
2114		else if ((field->flags & TEP_FIELD_IS_ARRAY) && strstr(field->type, "char")) {
2115			arg->scnprintf = SCA_CHAR_ARRAY;
2116			arg->nr_entries = field->arraylen;
2117		} else if ((strcmp(field->type, "int") == 0 ||
2118			  strcmp(field->type, "unsigned int") == 0 ||
2119			  strcmp(field->type, "long") == 0) &&
2120			 len >= 2 && strcmp(field->name + len - 2, "fd") == 0) {
2121			/*
2122			 * /sys/kernel/tracing/events/syscalls/sys_enter*
2123			 * grep -E 'field:.*fd;' .../format|sed -r 's/.*field:([a-z ]+) [a-z_]*fd.+/\1/g'|sort|uniq -c
2124			 * 65 int
2125			 * 23 unsigned int
2126			 * 7 unsigned long
2127			 */
2128			arg->scnprintf = SCA_FD;
2129		} else if (strstr(field->type, "enum") && use_btf != NULL) {
2130			*use_btf = true;
2131			arg->strtoul = STUL_BTF_TYPE;
2132		} else {
2133			const struct syscall_arg_fmt *fmt =
2134				syscall_arg_fmt__find_by_name(field->name);
2135
2136			if (fmt) {
2137				arg->scnprintf = fmt->scnprintf;
2138				arg->strtoul   = fmt->strtoul;
2139			}
2140		}
2141	}
2142
2143	return last_field;
2144}
2145
2146static int syscall__set_arg_fmts(struct syscall *sc)
2147{
2148	struct tep_format_field *last_field = syscall_arg_fmt__init_array(sc->arg_fmt, sc->args,
2149									  &sc->use_btf);
2150
2151	if (last_field)
2152		sc->args_size = last_field->offset + last_field->size;
2153
2154	return 0;
2155}
2156
2157static int syscall__read_info(struct syscall *sc, struct trace *trace)
2158{
2159	char tp_name[128];
2160	const char *name;
2161	struct tep_format_field *field;
2162	int err;
2163
2164	if (sc->nonexistent)
2165		return -EEXIST;
2166
2167	if (sc->name) {
2168		/* Info already read. */
2169		return 0;
2170	}
2171
2172	name = syscalltbl__name(sc->e_machine, sc->id);
2173	if (name == NULL) {
2174		sc->nonexistent = true;
2175		return -EEXIST;
2176	}
2177
2178	sc->name = name;
2179	sc->fmt  = syscall_fmt__find(sc->name);
2180
2181	snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
2182	sc->tp_format = trace_event__tp_format("syscalls", tp_name);
2183
2184	if (IS_ERR(sc->tp_format) && sc->fmt && sc->fmt->alias) {
2185		snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
2186		sc->tp_format = trace_event__tp_format("syscalls", tp_name);
2187	}
2188
2189	/*
2190	 * Fails to read trace point format via sysfs node, so the trace point
2191	 * doesn't exist.  Set the 'nonexistent' flag as true.
2192	 */
2193	if (IS_ERR(sc->tp_format)) {
2194		sc->nonexistent = true;
2195		err = PTR_ERR(sc->tp_format);
2196		sc->tp_format = NULL;
2197		return err;
2198	}
2199
2200	/*
2201	 * The tracepoint format contains __syscall_nr field, so it's one more
2202	 * than the actual number of syscall arguments.
2203	 */
2204	if (syscall__alloc_arg_fmts(sc, sc->tp_format->format.nr_fields - 1))
2205		return -ENOMEM;
2206
2207	sc->args = sc->tp_format->format.fields;
2208	/*
2209	 * We need to check and discard the first variable '__syscall_nr'
2210	 * or 'nr' that mean the syscall number. It is needless here.
2211	 * So drop '__syscall_nr' or 'nr' field but does not exist on older kernels.
2212	 */
2213	if (sc->args && (!strcmp(sc->args->name, "__syscall_nr") || !strcmp(sc->args->name, "nr"))) {
2214		sc->args = sc->args->next;
2215		--sc->nr_args;
2216	}
2217
2218	field = sc->args;
2219	while (field) {
2220		if (is_internal_field(field))
2221			--sc->nr_args;
2222		field = field->next;
2223	}
2224
2225	sc->is_exit = !strcmp(name, "exit_group") || !strcmp(name, "exit");
2226	sc->is_open = !strcmp(name, "open") || !strcmp(name, "openat");
2227
2228	err = syscall__set_arg_fmts(sc);
2229
2230	/* after calling syscall__set_arg_fmts() we'll know whether use_btf is true */
2231	if (sc->use_btf)
2232		trace__load_vmlinux_btf(trace);
2233
2234	return err;
2235}
2236
2237static int evsel__init_tp_arg_scnprintf(struct evsel *evsel, bool *use_btf)
2238{
2239	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
2240
2241	if (fmt != NULL) {
2242		const struct tep_event *tp_format = evsel__tp_format(evsel);
2243
2244		if (tp_format) {
2245			syscall_arg_fmt__init_array(fmt, tp_format->format.fields, use_btf);
2246			return 0;
2247		}
2248	}
2249
2250	return -ENOMEM;
2251}
2252
2253static int intcmp(const void *a, const void *b)
2254{
2255	const int *one = a, *another = b;
2256
2257	return *one - *another;
2258}
2259
2260static int trace__validate_ev_qualifier(struct trace *trace)
2261{
2262	int err = 0;
2263	bool printed_invalid_prefix = false;
2264	struct str_node *pos;
2265	size_t nr_used = 0, nr_allocated = strlist__nr_entries(trace->ev_qualifier);
2266
2267	trace->ev_qualifier_ids.entries = malloc(nr_allocated *
2268						 sizeof(trace->ev_qualifier_ids.entries[0]));
2269
2270	if (trace->ev_qualifier_ids.entries == NULL) {
2271		fputs("Error:\tNot enough memory for allocating events qualifier ids\n",
2272		       trace->output);
2273		err = -EINVAL;
2274		goto out;
2275	}
2276
2277	strlist__for_each_entry(pos, trace->ev_qualifier) {
2278		const char *sc = pos->s;
2279		/*
2280		 * TODO: Assume more than the validation/warnings are all for
2281		 * the same binary type as perf.
2282		 */
2283		int id = syscalltbl__id(EM_HOST, sc), match_next = -1;
2284
2285		if (id < 0) {
2286			id = syscalltbl__strglobmatch_first(EM_HOST, sc, &match_next);
2287			if (id >= 0)
2288				goto matches;
2289
2290			if (!printed_invalid_prefix) {
2291				pr_debug("Skipping unknown syscalls: ");
2292				printed_invalid_prefix = true;
2293			} else {
2294				pr_debug(", ");
2295			}
2296
2297			pr_debug("%s", sc);
2298			continue;
2299		}
2300matches:
2301		trace->ev_qualifier_ids.entries[nr_used++] = id;
2302		if (match_next == -1)
2303			continue;
2304
2305		while (1) {
2306			id = syscalltbl__strglobmatch_next(EM_HOST, sc, &match_next);
2307			if (id < 0)
2308				break;
2309			if (nr_allocated == nr_used) {
2310				void *entries;
2311
2312				nr_allocated += 8;
2313				entries = realloc(trace->ev_qualifier_ids.entries,
2314						  nr_allocated * sizeof(trace->ev_qualifier_ids.entries[0]));
2315				if (entries == NULL) {
2316					err = -ENOMEM;
2317					fputs("\nError:\t Not enough memory for parsing\n", trace->output);
2318					goto out_free;
2319				}
2320				trace->ev_qualifier_ids.entries = entries;
2321			}
2322			trace->ev_qualifier_ids.entries[nr_used++] = id;
2323		}
2324	}
2325
2326	trace->ev_qualifier_ids.nr = nr_used;
2327	qsort(trace->ev_qualifier_ids.entries, nr_used, sizeof(int), intcmp);
2328out:
2329	if (printed_invalid_prefix)
2330		pr_debug("\n");
2331	return err;
2332out_free:
2333	zfree(&trace->ev_qualifier_ids.entries);
2334	trace->ev_qualifier_ids.nr = 0;
2335	goto out;
2336}
2337
2338static __maybe_unused bool trace__syscall_enabled(struct trace *trace, int id)
2339{
2340	bool in_ev_qualifier;
2341
2342	if (trace->ev_qualifier_ids.nr == 0)
2343		return true;
2344
2345	in_ev_qualifier = bsearch(&id, trace->ev_qualifier_ids.entries,
2346				  trace->ev_qualifier_ids.nr, sizeof(int), intcmp) != NULL;
2347
2348	if (in_ev_qualifier)
2349	       return !trace->not_ev_qualifier;
2350
2351	return trace->not_ev_qualifier;
2352}
2353
2354/*
2355 * args is to be interpreted as a series of longs but we need to handle
2356 * 8-byte unaligned accesses. args points to raw_data within the event
2357 * and raw_data is guaranteed to be 8-byte unaligned because it is
2358 * preceded by raw_size which is a u32. So we need to copy args to a temp
2359 * variable to read it. Most notably this avoids extended load instructions
2360 * on unaligned addresses
2361 */
2362unsigned long syscall_arg__val(struct syscall_arg *arg, u8 idx)
2363{
2364	unsigned long val;
2365	unsigned char *p = arg->args + sizeof(unsigned long) * idx;
2366
2367	memcpy(&val, p, sizeof(val));
2368	return val;
2369}
2370
2371static size_t syscall__scnprintf_name(struct syscall *sc, char *bf, size_t size,
2372				      struct syscall_arg *arg)
2373{
2374	if (sc->arg_fmt && sc->arg_fmt[arg->idx].name)
2375		return scnprintf(bf, size, "%s: ", sc->arg_fmt[arg->idx].name);
2376
2377	return scnprintf(bf, size, "arg%d: ", arg->idx);
2378}
2379
2380/*
2381 * Check if the value is in fact zero, i.e. mask whatever needs masking, such
2382 * as mount 'flags' argument that needs ignoring some magic flag, see comment
2383 * in tools/perf/trace/beauty/mount_flags.c
2384 */
2385static unsigned long syscall_arg_fmt__mask_val(struct syscall_arg_fmt *fmt, struct syscall_arg *arg, unsigned long val)
2386{
2387	if (fmt && fmt->mask_val)
2388		return fmt->mask_val(arg, val);
2389
2390	return val;
2391}
2392
2393static size_t syscall_arg_fmt__scnprintf_val(struct syscall_arg_fmt *fmt, char *bf, size_t size,
2394					     struct syscall_arg *arg, unsigned long val)
2395{
2396	if (fmt && fmt->scnprintf) {
2397		arg->val = val;
2398		if (fmt->parm)
2399			arg->parm = fmt->parm;
2400		return fmt->scnprintf(bf, size, arg);
2401	}
2402	return scnprintf(bf, size, "%ld", val);
2403}
2404
2405static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
2406				      unsigned char *args, void *augmented_args, int augmented_args_size,
2407				      struct trace *trace, struct thread *thread)
2408{
2409	size_t printed = 0, btf_printed;
2410	unsigned long val;
2411	u8 bit = 1;
2412	struct syscall_arg arg = {
2413		.args	= args,
2414		.augmented = {
2415			.size = augmented_args_size,
2416			.args = augmented_args,
2417		},
2418		.idx	= 0,
2419		.mask	= 0,
2420		.trace  = trace,
2421		.thread = thread,
2422		.show_string_prefix = trace->show_string_prefix,
2423	};
2424	struct thread_trace *ttrace = thread__priv(thread);
2425	void *default_scnprintf;
2426
2427	/*
2428	 * Things like fcntl will set this in its 'cmd' formatter to pick the
2429	 * right formatter for the return value (an fd? file flags?), which is
2430	 * not needed for syscalls that always return a given type, say an fd.
2431	 */
2432	ttrace->ret_scnprintf = NULL;
2433
2434	if (sc->args != NULL) {
2435		struct tep_format_field *field;
2436
2437		for (field = sc->args; field;
2438		     field = field->next, ++arg.idx, bit <<= 1) {
2439			if (arg.mask & bit)
2440				continue;
2441
2442			arg.fmt = &sc->arg_fmt[arg.idx];
2443			val = syscall_arg__val(&arg, arg.idx);
2444			/*
2445			 * Some syscall args need some mask, most don't and
2446			 * return val untouched.
2447			 */
2448			val = syscall_arg_fmt__mask_val(&sc->arg_fmt[arg.idx], &arg, val);
2449
2450			/*
2451			 * Suppress this argument if its value is zero and show_zero
2452			 * property isn't set.
2453			 *
2454			 * If it has a BTF type, then override the zero suppression knob
2455			 * as the common case is for zero in an enum to have an associated entry.
2456			 */
2457			if (val == 0 && !trace->show_zeros &&
2458			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].show_zero) &&
2459			    !(sc->arg_fmt && sc->arg_fmt[arg.idx].strtoul == STUL_BTF_TYPE))
2460				continue;
2461
2462			printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
2463
2464			if (trace->show_arg_names)
2465				printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
2466
2467			default_scnprintf = sc->arg_fmt[arg.idx].scnprintf;
2468
2469			if (trace->force_btf || default_scnprintf == NULL || default_scnprintf == SCA_PTR) {
2470				btf_printed = trace__btf_scnprintf(trace, &arg, bf + printed,
2471								   size - printed, val, field->type);
2472				if (btf_printed) {
2473					printed += btf_printed;
2474					continue;
2475				}
2476			}
2477
2478			printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx],
2479								  bf + printed, size - printed, &arg, val);
2480		}
2481	} else if (IS_ERR(sc->tp_format)) {
2482		/*
2483		 * If we managed to read the tracepoint /format file, then we
2484		 * may end up not having any args, like with gettid(), so only
2485		 * print the raw args when we didn't manage to read it.
2486		 */
2487		while (arg.idx < sc->nr_args) {
2488			if (arg.mask & bit)
2489				goto next_arg;
2490			val = syscall_arg__val(&arg, arg.idx);
2491			if (printed)
2492				printed += scnprintf(bf + printed, size - printed, ", ");
2493			printed += syscall__scnprintf_name(sc, bf + printed, size - printed, &arg);
2494			printed += syscall_arg_fmt__scnprintf_val(&sc->arg_fmt[arg.idx], bf + printed, size - printed, &arg, val);
2495next_arg:
2496			++arg.idx;
2497			bit <<= 1;
2498		}
2499	}
2500
2501	return printed;
2502}
2503
2504static struct syscall *syscall__new(int e_machine, int id)
2505{
2506	struct syscall *sc = zalloc(sizeof(*sc));
2507
2508	if (!sc)
2509		return NULL;
2510
2511	sc->e_machine = e_machine;
2512	sc->id = id;
2513	return sc;
2514}
2515
2516static void syscall__delete(struct syscall *sc)
2517{
2518	if (!sc)
2519		return;
2520
2521	free(sc->arg_fmt);
2522	free(sc);
2523}
2524
2525static int syscall__bsearch_cmp(const void *key, const void *entry)
2526{
2527	const struct syscall *a = key, *b = *((const struct syscall **)entry);
2528
2529	if (a->e_machine != b->e_machine)
2530		return a->e_machine - b->e_machine;
2531
2532	return a->id - b->id;
2533}
2534
2535static int syscall__cmp(const void *va, const void *vb)
2536{
2537	const struct syscall *a = *((const struct syscall **)va);
2538	const struct syscall *b = *((const struct syscall **)vb);
2539
2540	if (a->e_machine != b->e_machine)
2541		return a->e_machine - b->e_machine;
2542
2543	return a->id - b->id;
2544}
2545
2546static struct syscall *trace__find_syscall(struct trace *trace, int e_machine, int id)
2547{
2548	struct syscall key = {
2549		.e_machine = e_machine,
2550		.id = id,
2551	};
2552	struct syscall *sc, **tmp;
2553
2554	if (trace->syscalls.table) {
2555		struct syscall **sc_entry = bsearch(&key, trace->syscalls.table,
2556						    trace->syscalls.table_size,
2557						    sizeof(trace->syscalls.table[0]),
2558						    syscall__bsearch_cmp);
2559
2560		if (sc_entry)
2561			return *sc_entry;
2562	}
2563
2564	sc = syscall__new(e_machine, id);
2565	if (!sc)
2566		return NULL;
2567
2568	tmp = reallocarray(trace->syscalls.table, trace->syscalls.table_size + 1,
2569			   sizeof(trace->syscalls.table[0]));
2570	if (!tmp) {
2571		syscall__delete(sc);
2572		return NULL;
2573	}
2574
2575	trace->syscalls.table = tmp;
2576	trace->syscalls.table[trace->syscalls.table_size++] = sc;
2577	qsort(trace->syscalls.table, trace->syscalls.table_size, sizeof(trace->syscalls.table[0]),
2578	      syscall__cmp);
2579	return sc;
2580}
2581
2582typedef int (*tracepoint_handler)(struct trace *trace, struct evsel *evsel,
2583				  union perf_event *event,
2584				  struct perf_sample *sample);
2585
2586static struct syscall *trace__syscall_info(struct trace *trace, struct evsel *evsel,
2587					   int e_machine, int id)
2588{
2589	struct syscall *sc;
2590	int err = 0;
2591
2592	if (id < 0) {
2593
2594		/*
2595		 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
2596		 * before that, leaving at a higher verbosity level till that is
2597		 * explained. Reproduced with plain ftrace with:
2598		 *
2599		 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
2600		 * grep "NR -1 " /t/trace_pipe
2601		 *
2602		 * After generating some load on the machine.
2603 		 */
2604		if (verbose > 1) {
2605			static u64 n;
2606			fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
2607				id, evsel__name(evsel), ++n);
2608		}
2609		return NULL;
2610	}
2611
2612	err = -EINVAL;
2613
2614	sc = trace__find_syscall(trace, e_machine, id);
2615	if (sc)
2616		err = syscall__read_info(sc, trace);
2617
2618	if (err && verbose > 0) {
2619		char sbuf[STRERR_BUFSIZE];
2620
2621		fprintf(trace->output, "Problems reading syscall %d: %d (%s)", id, -err,
2622			str_error_r(-err, sbuf, sizeof(sbuf)));
2623		if (sc && sc->name)
2624			fprintf(trace->output, "(%s)", sc->name);
2625		fputs(" information\n", trace->output);
2626	}
2627	return err ? NULL : sc;
2628}
2629
2630struct syscall_stats {
2631	struct stats stats;
2632	u64	     nr_failures;
2633	int	     max_errno;
2634	u32	     *errnos;
2635};
2636
2637static void thread__update_stats(struct thread *thread, struct thread_trace *ttrace,
2638				 int id, struct perf_sample *sample, long err,
2639				 struct trace *trace)
2640{
2641	struct hashmap *syscall_stats = ttrace->syscall_stats;
2642	struct syscall_stats *stats = NULL;
2643	u64 duration = 0;
2644
2645	if (trace->summary_bpf)
2646		return;
2647
2648	if (trace->summary_mode == SUMMARY__BY_TOTAL)
2649		syscall_stats = trace->syscall_stats;
2650
2651	if (!hashmap__find(syscall_stats, id, &stats)) {
2652		stats = zalloc(sizeof(*stats));
2653		if (stats == NULL)
2654			return;
2655
2656		init_stats(&stats->stats);
2657		if (hashmap__add(syscall_stats, id, stats) < 0) {
2658			free(stats);
2659			return;
2660		}
2661	}
2662
2663	if (ttrace->entry_time && sample->time > ttrace->entry_time)
2664		duration = sample->time - ttrace->entry_time;
2665
2666	update_stats(&stats->stats, duration);
2667
2668	if (err < 0) {
2669		++stats->nr_failures;
2670
2671		if (!trace->errno_summary)
2672			return;
2673
2674		err = -err;
2675		if (err > stats->max_errno) {
2676			u32 *new_errnos = realloc(stats->errnos, err * sizeof(u32));
2677
2678			if (new_errnos) {
2679				memset(new_errnos + stats->max_errno, 0, (err - stats->max_errno) * sizeof(u32));
2680			} else {
2681				pr_debug("Not enough memory for errno stats for thread \"%s\"(%d/%d), results will be incomplete\n",
2682					 thread__comm_str(thread), thread__pid(thread),
2683					 thread__tid(thread));
2684				return;
2685			}
2686
2687			stats->errnos = new_errnos;
2688			stats->max_errno = err;
2689		}
2690
2691		++stats->errnos[err - 1];
2692	}
2693}
2694
2695static int trace__printf_interrupted_entry(struct trace *trace)
2696{
2697	struct thread_trace *ttrace;
2698	size_t printed;
2699	int len;
2700
2701	if (trace->failure_only || trace->current == NULL)
2702		return 0;
2703
2704	ttrace = thread__priv(trace->current);
2705
2706	if (!ttrace->entry_pending)
2707		return 0;
2708
2709	printed  = trace__fprintf_entry_head(trace, trace->current, 0, false, ttrace->entry_time, trace->output);
2710	printed += len = fprintf(trace->output, "%s)", ttrace->entry_str);
2711
2712	if (len < trace->args_alignment - 4)
2713		printed += fprintf(trace->output, "%-*s", trace->args_alignment - 4 - len, " ");
2714
2715	printed += fprintf(trace->output, " ...\n");
2716
2717	ttrace->entry_pending = false;
2718	++trace->nr_events_printed;
2719
2720	return printed;
2721}
2722
2723static int trace__fprintf_sample(struct trace *trace, struct evsel *evsel,
2724				 struct perf_sample *sample, struct thread *thread)
2725{
2726	int printed = 0;
2727
2728	if (trace->print_sample) {
2729		double ts = (double)sample->time / NSEC_PER_MSEC;
2730
2731		printed += fprintf(trace->output, "%22s %10.3f %s %d/%d [%d]\n",
2732				   evsel__name(evsel), ts,
2733				   thread__comm_str(thread),
2734				   sample->pid, sample->tid, sample->cpu);
2735	}
2736
2737	return printed;
2738}
2739
2740static void *syscall__augmented_args(struct syscall *sc, struct perf_sample *sample, int *augmented_args_size, int raw_augmented_args_size)
2741{
2742	/*
2743	 * For now with BPF raw_augmented we hook into raw_syscalls:sys_enter
2744	 * and there we get all 6 syscall args plus the tracepoint common fields
2745	 * that gets calculated at the start and the syscall_nr (another long).
2746	 * So we check if that is the case and if so don't look after the
2747	 * sc->args_size but always after the full raw_syscalls:sys_enter payload,
2748	 * which is fixed.
2749	 *
2750	 * We'll revisit this later to pass s->args_size to the BPF augmenter
2751	 * (now tools/perf/examples/bpf/augmented_raw_syscalls.c, so that it
2752	 * copies only what we need for each syscall, like what happens when we
2753	 * use syscalls:sys_enter_NAME, so that we reduce the kernel/userspace
2754	 * traffic to just what is needed for each syscall.
2755	 */
2756	int args_size = raw_augmented_args_size ?: sc->args_size;
2757
2758	*augmented_args_size = sample->raw_size - args_size;
2759	if (*augmented_args_size > 0) {
2760		static uintptr_t argbuf[1024]; /* assuming single-threaded */
2761
2762		if ((size_t)(*augmented_args_size) > sizeof(argbuf))
2763			return NULL;
2764
2765		/*
2766		 * The perf ring-buffer is 8-byte aligned but sample->raw_data
2767		 * is not because it's preceded by u32 size.  Later, beautifier
2768		 * will use the augmented args with stricter alignments like in
2769		 * some struct.  To make sure it's aligned, let's copy the args
2770		 * into a static buffer as it's single-threaded for now.
2771		 */
2772		memcpy(argbuf, sample->raw_data + args_size, *augmented_args_size);
2773
2774		return argbuf;
2775	}
2776	return NULL;
2777}
2778
2779static int trace__sys_enter(struct trace *trace, struct evsel *evsel,
2780			    union perf_event *event __maybe_unused,
2781			    struct perf_sample *sample)
2782{
2783	char *msg;
2784	void *args;
2785	int printed = 0;
2786	struct thread *thread;
2787	int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
2788	int augmented_args_size = 0, e_machine;
2789	void *augmented_args = NULL;
2790	struct syscall *sc;
2791	struct thread_trace *ttrace;
2792
2793	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2794	e_machine = thread__e_machine(thread, trace->host);
2795	sc = trace__syscall_info(trace, evsel, e_machine, id);
2796	if (sc == NULL)
2797		goto out_put;
2798	ttrace = thread__trace(thread, trace);
2799	if (ttrace == NULL)
2800		goto out_put;
2801
2802	trace__fprintf_sample(trace, evsel, sample, thread);
2803
2804	args = perf_evsel__sc_tp_ptr(evsel, args, sample);
2805
2806	if (ttrace->entry_str == NULL) {
2807		ttrace->entry_str = malloc(trace__entry_str_size);
2808		if (!ttrace->entry_str)
2809			goto out_put;
2810	}
2811
2812	if (!(trace->duration_filter || trace->summary_only || trace->min_stack))
2813		trace__printf_interrupted_entry(trace);
2814	/*
2815	 * If this is raw_syscalls.sys_enter, then it always comes with the 6 possible
2816	 * arguments, even if the syscall being handled, say "openat", uses only 4 arguments
2817	 * this breaks syscall__augmented_args() check for augmented args, as we calculate
2818	 * syscall->args_size using each syscalls:sys_enter_NAME tracefs format file,
2819	 * so when handling, say the openat syscall, we end up getting 6 args for the
2820	 * raw_syscalls:sys_enter event, when we expected just 4, we end up mistakenly
2821	 * thinking that the extra 2 u64 args are the augmented filename, so just check
2822	 * here and avoid using augmented syscalls when the evsel is the raw_syscalls one.
2823	 */
2824	if (evsel != trace->syscalls.events.sys_enter)
2825		augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size, trace->raw_augmented_syscalls_args_size);
2826	ttrace->entry_time = sample->time;
2827	msg = ttrace->entry_str;
2828	printed += scnprintf(msg + printed, trace__entry_str_size - printed, "%s(", sc->name);
2829
2830	printed += syscall__scnprintf_args(sc, msg + printed, trace__entry_str_size - printed,
2831					   args, augmented_args, augmented_args_size, trace, thread);
2832
2833	if (sc->is_exit) {
2834		if (!(trace->duration_filter || trace->summary_only || trace->failure_only || trace->min_stack)) {
2835			int alignment = 0;
2836
2837			trace__fprintf_entry_head(trace, thread, 0, false, ttrace->entry_time, trace->output);
2838			printed = fprintf(trace->output, "%s)", ttrace->entry_str);
2839			if (trace->args_alignment > printed)
2840				alignment = trace->args_alignment - printed;
2841			fprintf(trace->output, "%*s= ?\n", alignment, " ");
2842		}
2843	} else {
2844		ttrace->entry_pending = true;
2845		/* See trace__vfs_getname & trace__sys_exit */
2846		ttrace->filename.pending_open = false;
2847	}
2848
2849	if (trace->current != thread) {
2850		thread__put(trace->current);
2851		trace->current = thread__get(thread);
2852	}
2853	err = 0;
2854out_put:
2855	thread__put(thread);
2856	return err;
2857}
2858
2859static int trace__fprintf_sys_enter(struct trace *trace, struct evsel *evsel,
2860				    struct perf_sample *sample)
2861{
2862	struct thread_trace *ttrace;
2863	struct thread *thread;
2864	int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;
2865	struct syscall *sc;
2866	char msg[1024];
2867	void *args, *augmented_args = NULL;
2868	int augmented_args_size, e_machine;
2869	size_t printed = 0;
2870
2871
2872	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2873	e_machine = thread__e_machine(thread, trace->host);
2874	sc = trace__syscall_info(trace, evsel, e_machine, id);
2875	if (sc == NULL)
2876		goto out_put;
2877	ttrace = thread__trace(thread, trace);
2878	/*
2879	 * We need to get ttrace just to make sure it is there when syscall__scnprintf_args()
2880	 * and the rest of the beautifiers accessing it via struct syscall_arg touches it.
2881	 */
2882	if (ttrace == NULL)
2883		goto out_put;
2884
2885	args = perf_evsel__sc_tp_ptr(evsel, args, sample);
2886	augmented_args = syscall__augmented_args(sc, sample, &augmented_args_size, trace->raw_augmented_syscalls_args_size);
2887	printed += syscall__scnprintf_args(sc, msg, sizeof(msg), args, augmented_args, augmented_args_size, trace, thread);
2888	fprintf(trace->output, "%.*s", (int)printed, msg);
2889	err = 0;
2890out_put:
2891	thread__put(thread);
2892	return err;
2893}
2894
2895static int trace__resolve_callchain(struct trace *trace, struct evsel *evsel,
2896				    struct perf_sample *sample,
2897				    struct callchain_cursor *cursor)
2898{
2899	struct addr_location al;
2900	int max_stack = evsel->core.attr.sample_max_stack ?
2901			evsel->core.attr.sample_max_stack :
2902			trace->max_stack;
2903	int err = -1;
2904
2905	addr_location__init(&al);
2906	if (machine__resolve(trace->host, &al, sample) < 0)
2907		goto out;
2908
2909	err = thread__resolve_callchain(al.thread, cursor, evsel, sample, NULL, NULL, max_stack);
2910out:
2911	addr_location__exit(&al);
2912	return err;
2913}
2914
2915static int trace__fprintf_callchain(struct trace *trace, struct perf_sample *sample)
2916{
2917	/* TODO: user-configurable print_opts */
2918	const unsigned int print_opts = EVSEL__PRINT_SYM |
2919				        EVSEL__PRINT_DSO |
2920				        EVSEL__PRINT_UNKNOWN_AS_ADDR;
2921
2922	return sample__fprintf_callchain(sample, 38, print_opts, get_tls_callchain_cursor(), symbol_conf.bt_stop_list, trace->output);
2923}
2924
2925static int trace__sys_exit(struct trace *trace, struct evsel *evsel,
2926			   union perf_event *event __maybe_unused,
2927			   struct perf_sample *sample)
2928{
2929	long ret;
2930	u64 duration = 0;
2931	bool duration_calculated = false;
2932	struct thread *thread;
2933	int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0, printed = 0;
2934	int alignment = trace->args_alignment, e_machine;
2935	struct syscall *sc;
2936	struct thread_trace *ttrace;
2937
2938	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
2939	e_machine = thread__e_machine(thread, trace->host);
2940	sc = trace__syscall_info(trace, evsel, e_machine, id);
2941	if (sc == NULL)
2942		goto out_put;
2943	ttrace = thread__trace(thread, trace);
2944	if (ttrace == NULL)
2945		goto out_put;
2946
2947	trace__fprintf_sample(trace, evsel, sample, thread);
2948
2949	ret = perf_evsel__sc_tp_uint(evsel, ret, sample);
2950
2951	if (trace->summary)
2952		thread__update_stats(thread, ttrace, id, sample, ret, trace);
2953
2954	if (!trace->fd_path_disabled && sc->is_open && ret >= 0 && ttrace->filename.pending_open) {
2955		trace__set_fd_pathname(thread, ret, ttrace->filename.name);
2956		ttrace->filename.pending_open = false;
2957		++trace->stats.vfs_getname;
2958	}
2959
2960	if (ttrace->entry_time) {
2961		duration = sample->time - ttrace->entry_time;
2962		if (trace__filter_duration(trace, duration))
2963			goto out;
2964		duration_calculated = true;
2965	} else if (trace->duration_filter)
2966		goto out;
2967
2968	if (sample->callchain) {
2969		struct callchain_cursor *cursor = get_tls_callchain_cursor();
2970
2971		callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);
2972		if (callchain_ret == 0) {
2973			if (cursor->nr < trace->min_stack)
2974				goto out;
2975			callchain_ret = 1;
2976		}
2977	}
2978
2979	if (trace->summary_only || (ret >= 0 && trace->failure_only))
2980		goto out;
2981
2982	trace__fprintf_entry_head(trace, thread, duration, duration_calculated, ttrace->entry_time, trace->output);
2983
2984	if (ttrace->entry_pending) {
2985		printed = fprintf(trace->output, "%s", ttrace->entry_str);
2986	} else {
2987		printed += fprintf(trace->output, " ... [");
2988		color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
2989		printed += 9;
2990		printed += fprintf(trace->output, "]: %s()", sc->name);
2991	}
2992
2993	printed++; /* the closing ')' */
2994
2995	if (alignment > printed)
2996		alignment -= printed;
2997	else
2998		alignment = 0;
2999
3000	fprintf(trace->output, ")%*s= ", alignment, " ");
3001
3002	if (sc->fmt == NULL) {
3003		if (ret < 0)
3004			goto errno_print;
3005signed_print:
3006		fprintf(trace->output, "%ld", ret);
3007	} else if (ret < 0) {
3008errno_print: {
3009		char bf[STRERR_BUFSIZE];
3010		struct perf_env *env = evsel__env(evsel) ?: &trace->host_env;
3011		const char *emsg = str_error_r(-ret, bf, sizeof(bf));
3012		const char *e = perf_env__arch_strerrno(env, err);
3013
3014		fprintf(trace->output, "-1 %s (%s)", e, emsg);
3015	}
3016	} else if (ret == 0 && sc->fmt->timeout)
3017		fprintf(trace->output, "0 (Timeout)");
3018	else if (ttrace->ret_scnprintf) {
3019		char bf[1024];
3020		struct syscall_arg arg = {
3021			.val	= ret,
3022			.thread	= thread,
3023			.trace	= trace,
3024		};
3025		ttrace->ret_scnprintf(bf, sizeof(bf), &arg);
3026		ttrace->ret_scnprintf = NULL;
3027		fprintf(trace->output, "%s", bf);
3028	} else if (sc->fmt->hexret)
3029		fprintf(trace->output, "%#lx", ret);
3030	else if (sc->fmt->errpid) {
3031		struct thread *child = machine__find_thread(trace->host, ret, ret);
3032
3033		fprintf(trace->output, "%ld", ret);
3034		if (child != NULL) {
3035			if (thread__comm_set(child))
3036				fprintf(trace->output, " (%s)", thread__comm_str(child));
3037			thread__put(child);
3038		}
3039	} else
3040		goto signed_print;
3041
3042	fputc('\n', trace->output);
3043
3044	/*
3045	 * We only consider an 'event' for the sake of --max-events a non-filtered
3046	 * sys_enter + sys_exit and other tracepoint events.
3047	 */
3048	if (++trace->nr_events_printed == trace->max_events && trace->max_events != ULONG_MAX)
3049		interrupted = true;
3050
3051	if (callchain_ret > 0)
3052		trace__fprintf_callchain(trace, sample);
3053	else if (callchain_ret < 0)
3054		pr_err("Problem processing %s callchain, skipping...\n", evsel__name(evsel));
3055out:
3056	ttrace->entry_pending = false;
3057	err = 0;
3058out_put:
3059	thread__put(thread);
3060	return err;
3061}
3062
3063static int trace__vfs_getname(struct trace *trace, struct evsel *evsel,
3064			      union perf_event *event __maybe_unused,
3065			      struct perf_sample *sample)
3066{
3067	struct thread *thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
3068	struct thread_trace *ttrace;
3069	size_t filename_len, entry_str_len, to_move;
3070	ssize_t remaining_space;
3071	char *pos;
3072	const char *filename = evsel__rawptr(evsel, sample, "pathname");
3073
3074	if (!thread)
3075		goto out;
3076
3077	ttrace = thread__priv(thread);
3078	if (!ttrace)
3079		goto out_put;
3080
3081	filename_len = strlen(filename);
3082	if (filename_len == 0)
3083		goto out_put;
3084
3085	if (ttrace->filename.namelen < filename_len) {
3086		char *f = realloc(ttrace->filename.name, filename_len + 1);
3087
3088		if (f == NULL)
3089			goto out_put;
3090
3091		ttrace->filename.namelen = filename_len;
3092		ttrace->filename.name = f;
3093	}
3094
3095	strcpy(ttrace->filename.name, filename);
3096	ttrace->filename.pending_open = true;
3097
3098	if (!ttrace->filename.ptr)
3099		goto out_put;
3100
3101	entry_str_len = strlen(ttrace->entry_str);
3102	remaining_space = trace__entry_str_size - entry_str_len - 1; /* \0 */
3103	if (remaining_space <= 0)
3104		goto out_put;
3105
3106	if (filename_len > (size_t)remaining_space) {
3107		filename += filename_len - remaining_space;
3108		filename_len = remaining_space;
3109	}
3110
3111	to_move = entry_str_len - ttrace->filename.entry_str_pos + 1; /* \0 */
3112	pos = ttrace->entry_str + ttrace->filename.entry_str_pos;
3113	memmove(pos + filename_len, pos, to_move);
3114	memcpy(pos, filename, filename_len);
3115
3116	ttrace->filename.ptr = 0;
3117	ttrace->filename.entry_str_pos = 0;
3118out_put:
3119	thread__put(thread);
3120out:
3121	return 0;
3122}
3123
3124static int trace__sched_stat_runtime(struct trace *trace, struct evsel *evsel,
3125				     union perf_event *event __maybe_unused,
3126				     struct perf_sample *sample)
3127{
3128        u64 runtime = evsel__intval(evsel, sample, "runtime");
3129	double runtime_ms = (double)runtime / NSEC_PER_MSEC;
3130	struct thread *thread = machine__findnew_thread(trace->host,
3131							sample->pid,
3132							sample->tid);
3133	struct thread_trace *ttrace = thread__trace(thread, trace);
3134
3135	if (ttrace == NULL)
3136		goto out_dump;
3137
3138	ttrace->runtime_ms += runtime_ms;
3139	trace->runtime_ms += runtime_ms;
3140out_put:
3141	thread__put(thread);
3142	return 0;
3143
3144out_dump:
3145	fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
3146	       evsel->name,
3147	       evsel__strval(evsel, sample, "comm"),
3148	       (pid_t)evsel__intval(evsel, sample, "pid"),
3149	       runtime,
3150	       evsel__intval(evsel, sample, "vruntime"));
3151	goto out_put;
3152}
3153
3154static int bpf_output__printer(enum binary_printer_ops op,
3155			       unsigned int val, void *extra __maybe_unused, FILE *fp)
3156{
3157	unsigned char ch = (unsigned char)val;
3158
3159	switch (op) {
3160	case BINARY_PRINT_CHAR_DATA:
3161		return fprintf(fp, "%c", isprint(ch) ? ch : '.');
3162	case BINARY_PRINT_DATA_BEGIN:
3163	case BINARY_PRINT_LINE_BEGIN:
3164	case BINARY_PRINT_ADDR:
3165	case BINARY_PRINT_NUM_DATA:
3166	case BINARY_PRINT_NUM_PAD:
3167	case BINARY_PRINT_SEP:
3168	case BINARY_PRINT_CHAR_PAD:
3169	case BINARY_PRINT_LINE_END:
3170	case BINARY_PRINT_DATA_END:
3171	default:
3172		break;
3173	}
3174
3175	return 0;
3176}
3177
3178static void bpf_output__fprintf(struct trace *trace,
3179				struct perf_sample *sample)
3180{
3181	binary__fprintf(sample->raw_data, sample->raw_size, 8,
3182			bpf_output__printer, NULL, trace->output);
3183	++trace->nr_events_printed;
3184}
3185
3186static size_t trace__fprintf_tp_fields(struct trace *trace, struct evsel *evsel, struct perf_sample *sample,
3187				       struct thread *thread, void *augmented_args, int augmented_args_size)
3188{
3189	char bf[2048];
3190	size_t size = sizeof(bf);
3191	const struct tep_event *tp_format = evsel__tp_format(evsel);
3192	struct tep_format_field *field = tp_format ? tp_format->format.fields : NULL;
3193	struct syscall_arg_fmt *arg = __evsel__syscall_arg_fmt(evsel);
3194	size_t printed = 0, btf_printed;
3195	unsigned long val;
3196	u8 bit = 1;
3197	struct syscall_arg syscall_arg = {
3198		.augmented = {
3199			.size = augmented_args_size,
3200			.args = augmented_args,
3201		},
3202		.idx	= 0,
3203		.mask	= 0,
3204		.trace  = trace,
3205		.thread = thread,
3206		.show_string_prefix = trace->show_string_prefix,
3207	};
3208
3209	for (; field && arg; field = field->next, ++syscall_arg.idx, bit <<= 1, ++arg) {
3210		if (syscall_arg.mask & bit)
3211			continue;
3212
3213		syscall_arg.len = 0;
3214		syscall_arg.fmt = arg;
3215		if (field->flags & TEP_FIELD_IS_ARRAY) {
3216			int offset = field->offset;
3217
3218			if (field->flags & TEP_FIELD_IS_DYNAMIC) {
3219				offset = format_field__intval(field, sample, evsel->needs_swap);
3220				syscall_arg.len = offset >> 16;
3221				offset &= 0xffff;
3222				if (tep_field_is_relative(field->flags))
3223					offset += field->offset + field->size;
3224			}
3225
3226			val = (uintptr_t)(sample->raw_data + offset);
3227		} else
3228			val = format_field__intval(field, sample, evsel->needs_swap);
3229		/*
3230		 * Some syscall args need some mask, most don't and
3231		 * return val untouched.
3232		 */
3233		val = syscall_arg_fmt__mask_val(arg, &syscall_arg, val);
3234
3235		/* Suppress this argument if its value is zero and show_zero property isn't set. */
3236		if (val == 0 && !trace->show_zeros && !arg->show_zero && arg->strtoul != STUL_BTF_TYPE)
3237			continue;
3238
3239		printed += scnprintf(bf + printed, size - printed, "%s", printed ? ", " : "");
3240
3241		if (trace->show_arg_names)
3242			printed += scnprintf(bf + printed, size - printed, "%s: ", field->name);
3243
3244		btf_printed = trace__btf_scnprintf(trace, &syscall_arg, bf + printed, size - printed, val, field->type);
3245		if (btf_printed) {
3246			printed += btf_printed;
3247			continue;
3248		}
3249
3250		printed += syscall_arg_fmt__scnprintf_val(arg, bf + printed, size - printed, &syscall_arg, val);
3251	}
3252
3253	return fprintf(trace->output, "%.*s", (int)printed, bf);
3254}
3255
3256static int trace__event_handler(struct trace *trace, struct evsel *evsel,
3257				union perf_event *event __maybe_unused,
3258				struct perf_sample *sample)
3259{
3260	struct thread *thread;
3261	int callchain_ret = 0;
3262
3263	if (evsel->nr_events_printed >= evsel->max_events)
3264		return 0;
3265
3266	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
3267
3268	if (sample->callchain) {
3269		struct callchain_cursor *cursor = get_tls_callchain_cursor();
3270
3271		callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);
3272		if (callchain_ret == 0) {
3273			if (cursor->nr < trace->min_stack)
3274				goto out;
3275			callchain_ret = 1;
3276		}
3277	}
3278
3279	trace__printf_interrupted_entry(trace);
3280	trace__fprintf_tstamp(trace, sample->time, trace->output);
3281
3282	if (trace->trace_syscalls && trace->show_duration)
3283		fprintf(trace->output, "(         ): ");
3284
3285	if (thread)
3286		trace__fprintf_comm_tid(trace, thread, trace->output);
3287
3288	if (evsel == trace->syscalls.events.bpf_output) {
3289		int id = perf_evsel__sc_tp_uint(evsel, id, sample);
3290		int e_machine = thread ? thread__e_machine(thread, trace->host) : EM_HOST;
3291		struct syscall *sc = trace__syscall_info(trace, evsel, e_machine, id);
3292
3293		if (sc) {
3294			fprintf(trace->output, "%s(", sc->name);
3295			trace__fprintf_sys_enter(trace, evsel, sample);
3296			fputc(')', trace->output);
3297			goto newline;
3298		}
3299
3300		/*
3301		 * XXX: Not having the associated syscall info or not finding/adding
3302		 * 	the thread should never happen, but if it does...
3303		 * 	fall thru and print it as a bpf_output event.
3304		 */
3305	}
3306
3307	fprintf(trace->output, "%s(", evsel->name);
3308
3309	if (evsel__is_bpf_output(evsel)) {
3310		bpf_output__fprintf(trace, sample);
3311	} else {
3312		const struct tep_event *tp_format = evsel__tp_format(evsel);
3313
3314		if (tp_format && (strncmp(tp_format->name, "sys_enter_", 10) ||
3315				  trace__fprintf_sys_enter(trace, evsel, sample))) {
3316			if (trace->libtraceevent_print) {
3317				event_format__fprintf(tp_format, sample->cpu,
3318						      sample->raw_data, sample->raw_size,
3319						      trace->output);
3320			} else {
3321				trace__fprintf_tp_fields(trace, evsel, sample, thread, NULL, 0);
3322			}
3323		}
3324	}
3325
3326newline:
3327	fprintf(trace->output, ")\n");
3328
3329	if (callchain_ret > 0)
3330		trace__fprintf_callchain(trace, sample);
3331	else if (callchain_ret < 0)
3332		pr_err("Problem processing %s callchain, skipping...\n", evsel__name(evsel));
3333
3334	++trace->nr_events_printed;
3335
3336	if (evsel->max_events != ULONG_MAX && ++evsel->nr_events_printed == evsel->max_events) {
3337		evsel__disable(evsel);
3338		evsel__close(evsel);
3339	}
3340out:
3341	thread__put(thread);
3342	return 0;
3343}
3344
3345static void print_location(FILE *f, struct perf_sample *sample,
3346			   struct addr_location *al,
3347			   bool print_dso, bool print_sym)
3348{
3349
3350	if ((verbose > 0 || print_dso) && al->map)
3351		fprintf(f, "%s@", dso__long_name(map__dso(al->map)));
3352
3353	if ((verbose > 0 || print_sym) && al->sym)
3354		fprintf(f, "%s+0x%" PRIx64, al->sym->name,
3355			al->addr - al->sym->start);
3356	else if (al->map)
3357		fprintf(f, "0x%" PRIx64, al->addr);
3358	else
3359		fprintf(f, "0x%" PRIx64, sample->addr);
3360}
3361
3362static int trace__pgfault(struct trace *trace,
3363			  struct evsel *evsel,
3364			  union perf_event *event __maybe_unused,
3365			  struct perf_sample *sample)
3366{
3367	struct thread *thread;
3368	struct addr_location al;
3369	char map_type = 'd';
3370	struct thread_trace *ttrace;
3371	int err = -1;
3372	int callchain_ret = 0;
3373
3374	addr_location__init(&al);
3375	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
3376
3377	if (sample->callchain) {
3378		struct callchain_cursor *cursor = get_tls_callchain_cursor();
3379
3380		callchain_ret = trace__resolve_callchain(trace, evsel, sample, cursor);
3381		if (callchain_ret == 0) {
3382			if (cursor->nr < trace->min_stack)
3383				goto out_put;
3384			callchain_ret = 1;
3385		}
3386	}
3387
3388	ttrace = thread__trace(thread, trace);
3389	if (ttrace == NULL)
3390		goto out_put;
3391
3392	if (evsel->core.attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ) {
3393		ttrace->pfmaj++;
3394		trace->pfmaj++;
3395	} else {
3396		ttrace->pfmin++;
3397		trace->pfmin++;
3398	}
3399
3400	if (trace->summary_only)
3401		goto out;
3402
3403	thread__find_symbol(thread, sample->cpumode, sample->ip, &al);
3404
3405	trace__fprintf_entry_head(trace, thread, 0, true, sample->time, trace->output);
3406
3407	fprintf(trace->output, "%sfault [",
3408		evsel->core.attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ?
3409		"maj" : "min");
3410
3411	print_location(trace->output, sample, &al, false, true);
3412
3413	fprintf(trace->output, "] => ");
3414
3415	thread__find_symbol(thread, sample->cpumode, sample->addr, &al);
3416
3417	if (!al.map) {
3418		thread__find_symbol(thread, sample->cpumode, sample->addr, &al);
3419
3420		if (al.map)
3421			map_type = 'x';
3422		else
3423			map_type = '?';
3424	}
3425
3426	print_location(trace->output, sample, &al, true, false);
3427
3428	fprintf(trace->output, " (%c%c)\n", map_type, al.level);
3429
3430	if (callchain_ret > 0)
3431		trace__fprintf_callchain(trace, sample);
3432	else if (callchain_ret < 0)
3433		pr_err("Problem processing %s callchain, skipping...\n", evsel__name(evsel));
3434
3435	++trace->nr_events_printed;
3436out:
3437	err = 0;
3438out_put:
3439	thread__put(thread);
3440	addr_location__exit(&al);
3441	return err;
3442}
3443
3444static void trace__set_base_time(struct trace *trace,
3445				 struct evsel *evsel,
3446				 struct perf_sample *sample)
3447{
3448	/*
3449	 * BPF events were not setting PERF_SAMPLE_TIME, so be more robust
3450	 * and don't use sample->time unconditionally, we may end up having
3451	 * some other event in the future without PERF_SAMPLE_TIME for good
3452	 * reason, i.e. we may not be interested in its timestamps, just in
3453	 * it taking place, picking some piece of information when it
3454	 * appears in our event stream (vfs_getname comes to mind).
3455	 */
3456	if (trace->base_time == 0 && !trace->full_time &&
3457	    (evsel->core.attr.sample_type & PERF_SAMPLE_TIME))
3458		trace->base_time = sample->time;
3459}
3460
3461static int trace__process_sample(const struct perf_tool *tool,
3462				 union perf_event *event,
3463				 struct perf_sample *sample,
3464				 struct evsel *evsel,
3465				 struct machine *machine __maybe_unused)
3466{
3467	struct trace *trace = container_of(tool, struct trace, tool);
3468	struct thread *thread;
3469	int err = 0;
3470
3471	tracepoint_handler handler = evsel->handler;
3472
3473	thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);
3474	if (thread && thread__is_filtered(thread))
3475		goto out;
3476
3477	trace__set_base_time(trace, evsel, sample);
3478
3479	if (handler) {
3480		++trace->nr_events;
3481		handler(trace, evsel, event, sample);
3482	}
3483out:
3484	thread__put(thread);
3485	return err;
3486}
3487
3488static int trace__record(struct trace *trace, int argc, const char **argv)
3489{
3490	unsigned int rec_argc, i, j;
3491	const char **rec_argv;
3492	const char * const record_args[] = {
3493		"record",
3494		"-R",
3495		"-m", "1024",
3496		"-c", "1",
3497	};
3498	pid_t pid = getpid();
3499	char *filter = asprintf__tp_filter_pids(1, &pid);
3500	const char * const sc_args[] = { "-e", };
3501	unsigned int sc_args_nr = ARRAY_SIZE(sc_args);
3502	const char * const majpf_args[] = { "-e", "major-faults" };
3503	unsigned int majpf_args_nr = ARRAY_SIZE(majpf_args);
3504	const char * const minpf_args[] = { "-e", "minor-faults" };
3505	unsigned int minpf_args_nr = ARRAY_SIZE(minpf_args);
3506	int err = -1;
3507
3508	/* +3 is for the event string below and the pid filter */
3509	rec_argc = ARRAY_SIZE(record_args) + sc_args_nr + 3 +
3510		majpf_args_nr + minpf_args_nr + argc;
3511	rec_argv = calloc(rec_argc + 1, sizeof(char *));
3512
3513	if (rec_argv == NULL || filter == NULL)
3514		goto out_free;
3515
3516	j = 0;
3517	for (i = 0; i < ARRAY_SIZE(record_args); i++)
3518		rec_argv[j++] = record_args[i];
3519
3520	if (trace->trace_syscalls) {
3521		for (i = 0; i < sc_args_nr; i++)
3522			rec_argv[j++] = sc_args[i];
3523
3524		/* event string may be different for older kernels - e.g., RHEL6 */
3525		if (is_valid_tracepoint("raw_syscalls:sys_enter"))
3526			rec_argv[j++] = "raw_syscalls:sys_enter,raw_syscalls:sys_exit";
3527		else if (is_valid_tracepoint("syscalls:sys_enter"))
3528			rec_argv[j++] = "syscalls:sys_enter,syscalls:sys_exit";
3529		else {
3530			pr_err("Neither raw_syscalls nor syscalls events exist.\n");
3531			goto out_free;
3532		}
3533	}
3534
3535	rec_argv[j++] = "--filter";
3536	rec_argv[j++] = filter;
3537
3538	if (trace->trace_pgfaults & TRACE_PFMAJ)
3539		for (i = 0; i < majpf_args_nr; i++)
3540			rec_argv[j++] = majpf_args[i];
3541
3542	if (trace->trace_pgfaults & TRACE_PFMIN)
3543		for (i = 0; i < minpf_args_nr; i++)
3544			rec_argv[j++] = minpf_args[i];
3545
3546	for (i = 0; i < (unsigned int)argc; i++)
3547		rec_argv[j++] = argv[i];
3548
3549	err = cmd_record(j, rec_argv);
3550out_free:
3551	free(filter);
3552	free(rec_argv);
3553	return err;
3554}
3555
3556static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);
3557static size_t trace__fprintf_total_summary(struct trace *trace, FILE *fp);
3558
3559static bool evlist__add_vfs_getname(struct evlist *evlist)
3560{
3561	bool found = false;
3562	struct evsel *evsel, *tmp;
3563	struct parse_events_error err;
3564	int ret;
3565
3566	parse_events_error__init(&err);
3567	ret = parse_events(evlist, "probe:vfs_getname*", &err);
3568	parse_events_error__exit(&err);
3569	if (ret)
3570		return false;
3571
3572	evlist__for_each_entry_safe(evlist, evsel, tmp) {
3573		if (!strstarts(evsel__name(evsel), "probe:vfs_getname"))
3574			continue;
3575
3576		if (evsel__field(evsel, "pathname")) {
3577			evsel->handler = trace__vfs_getname;
3578			found = true;
3579			continue;
3580		}
3581
3582		list_del_init(&evsel->core.node);
3583		evsel->evlist = NULL;
3584		evsel__delete(evsel);
3585	}
3586
3587	return found;
3588}
3589
3590static struct evsel *evsel__new_pgfault(u64 config)
3591{
3592	struct evsel *evsel;
3593	struct perf_event_attr attr = {
3594		.type = PERF_TYPE_SOFTWARE,
3595		.mmap_data = 1,
3596	};
3597
3598	attr.config = config;
3599	attr.sample_period = 1;
3600
3601	event_attr_init(&attr);
3602
3603	evsel = evsel__new(&attr);
3604	if (evsel)
3605		evsel->handler = trace__pgfault;
3606
3607	return evsel;
3608}
3609
3610static void evlist__free_syscall_tp_fields(struct evlist *evlist)
3611{
3612	struct evsel *evsel;
3613
3614	evlist__for_each_entry(evlist, evsel) {
3615		evsel_trace__delete(evsel->priv);
3616		evsel->priv = NULL;
3617	}
3618}
3619
3620static void trace__handle_event(struct trace *trace, union perf_event *event, struct perf_sample *sample)
3621{
3622	const u32 type = event->header.type;
3623	struct evsel *evsel;
3624
3625	if (type != PERF_RECORD_SAMPLE) {
3626		trace__process_event(trace, trace->host, event, sample);
3627		return;
3628	}
3629
3630	evsel = evlist__id2evsel(trace->evlist, sample->id);
3631	if (evsel == NULL) {
3632		fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
3633		return;
3634	}
3635
3636	if (evswitch__discard(&trace->evswitch, evsel))
3637		return;
3638
3639	trace__set_base_time(trace, evsel, sample);
3640
3641	if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT &&
3642	    sample->raw_data == NULL) {
3643		fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
3644		       evsel__name(evsel), sample->tid,
3645		       sample->cpu, sample->raw_size);
3646	} else {
3647		tracepoint_handler handler = evsel->handler;
3648		handler(trace, evsel, event, sample);
3649	}
3650
3651	if (trace->nr_events_printed >= trace->max_events && trace->max_events != ULONG_MAX)
3652		interrupted = true;
3653}
3654
3655static int trace__add_syscall_newtp(struct trace *trace)
3656{
3657	int ret = -1;
3658	struct evlist *evlist = trace->evlist;
3659	struct evsel *sys_enter, *sys_exit;
3660
3661	sys_enter = perf_evsel__raw_syscall_newtp("sys_enter", trace__sys_enter);
3662	if (sys_enter == NULL)
3663		goto out;
3664
3665	if (perf_evsel__init_sc_tp_ptr_field(sys_enter, args))
3666		goto out_delete_sys_enter;
3667
3668	sys_exit = perf_evsel__raw_syscall_newtp("sys_exit", trace__sys_exit);
3669	if (sys_exit == NULL)
3670		goto out_delete_sys_enter;
3671
3672	if (perf_evsel__init_sc_tp_uint_field(sys_exit, ret))
3673		goto out_delete_sys_exit;
3674
3675	evsel__config_callchain(sys_enter, &trace->opts, &callchain_param);
3676	evsel__config_callchain(sys_exit, &trace->opts, &callchain_param);
3677
3678	evlist__add(evlist, sys_enter);
3679	evlist__add(evlist, sys_exit);
3680
3681	if (callchain_param.enabled && !trace->kernel_syscallchains) {
3682		/*
3683		 * We're interested only in the user space callchain
3684		 * leading to the syscall, allow overriding that for
3685		 * debugging reasons using --kernel_syscall_callchains
3686		 */
3687		sys_exit->core.attr.exclude_callchain_kernel = 1;
3688	}
3689
3690	trace->syscalls.events.sys_enter = sys_enter;
3691	trace->syscalls.events.sys_exit  = sys_exit;
3692
3693	ret = 0;
3694out:
3695	return ret;
3696
3697out_delete_sys_exit:
3698	evsel__delete_priv(sys_exit);
3699out_delete_sys_enter:
3700	evsel__delete_priv(sys_enter);
3701	goto out;
3702}
3703
3704static int trace__set_ev_qualifier_tp_filter(struct trace *trace)
3705{
3706	int err = -1;
3707	struct evsel *sys_exit;
3708	char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
3709						trace->ev_qualifier_ids.nr,
3710						trace->ev_qualifier_ids.entries);
3711
3712	if (filter == NULL)
3713		goto out_enomem;
3714
3715	if (!evsel__append_tp_filter(trace->syscalls.events.sys_enter, filter)) {
3716		sys_exit = trace->syscalls.events.sys_exit;
3717		err = evsel__append_tp_filter(sys_exit, filter);
3718	}
3719
3720	free(filter);
3721out:
3722	return err;
3723out_enomem:
3724	errno = ENOMEM;
3725	goto out;
3726}
3727
3728#ifdef HAVE_LIBBPF_SUPPORT
3729
3730static struct bpf_program *unaugmented_prog;
3731
3732static int syscall_arg_fmt__cache_btf_struct(struct syscall_arg_fmt *arg_fmt, struct btf *btf, char *type)
3733{
3734       int id;
3735
3736	if (arg_fmt->type != NULL)
3737		return -1;
3738
3739       id = btf__find_by_name(btf, type);
3740       if (id < 0)
3741		return -1;
3742
3743       arg_fmt->type    = btf__type_by_id(btf, id);
3744       arg_fmt->type_id = id;
3745
3746       return 0;
3747}
3748
3749static struct bpf_program *trace__find_syscall_bpf_prog(struct trace *trace __maybe_unused,
3750							struct syscall *sc,
3751							const char *prog_name, const char *type)
3752{
3753	struct bpf_program *prog;
3754
3755	if (prog_name == NULL) {
3756		char default_prog_name[256];
3757		scnprintf(default_prog_name, sizeof(default_prog_name), "tp/syscalls/sys_%s_%s", type, sc->name);
3758		prog = augmented_syscalls__find_by_title(default_prog_name);
3759		if (prog != NULL)
3760			goto out_found;
3761		if (sc->fmt && sc->fmt->alias) {
3762			scnprintf(default_prog_name, sizeof(default_prog_name), "tp/syscalls/sys_%s_%s", type, sc->fmt->alias);
3763			prog = augmented_syscalls__find_by_title(default_prog_name);
3764			if (prog != NULL)
3765				goto out_found;
3766		}
3767		goto out_unaugmented;
3768	}
3769
3770	prog = augmented_syscalls__find_by_title(prog_name);
3771
3772	if (prog != NULL) {
3773out_found:
3774		return prog;
3775	}
3776
3777	pr_debug("Couldn't find BPF prog \"%s\" to associate with syscalls:sys_%s_%s, not augmenting it\n",
3778		 prog_name, type, sc->name);
3779out_unaugmented:
3780	return unaugmented_prog;
3781}
3782
3783static void trace__init_syscall_bpf_progs(struct trace *trace, int e_machine, int id)
3784{
3785	struct syscall *sc = trace__syscall_info(trace, NULL, e_machine, id);
3786
3787	if (sc == NULL)
3788		return;
3789
3790	sc->bpf_prog.sys_enter = trace__find_syscall_bpf_prog(trace, sc, sc->fmt ? sc->fmt->bpf_prog_name.sys_enter : NULL, "enter");
3791	sc->bpf_prog.sys_exit  = trace__find_syscall_bpf_prog(trace, sc, sc->fmt ? sc->fmt->bpf_prog_name.sys_exit  : NULL,  "exit");
3792}
3793
3794static int trace__bpf_prog_sys_enter_fd(struct trace *trace, int e_machine, int id)
3795{
3796	struct syscall *sc = trace__syscall_info(trace, NULL, e_machine, id);
3797	return sc ? bpf_program__fd(sc->bpf_prog.sys_enter) : bpf_program__fd(unaugmented_prog);
3798}
3799
3800static int trace__bpf_prog_sys_exit_fd(struct trace *trace, int e_machine, int id)
3801{
3802	struct syscall *sc = trace__syscall_info(trace, NULL, e_machine, id);
3803	return sc ? bpf_program__fd(sc->bpf_prog.sys_exit) : bpf_program__fd(unaugmented_prog);
3804}
3805
3806static int trace__bpf_sys_enter_beauty_map(struct trace *trace, int e_machine, int key, unsigned int *beauty_array)
3807{
3808	struct tep_format_field *field;
3809	struct syscall *sc = trace__syscall_info(trace, NULL, e_machine, key);
3810	const struct btf_type *bt;
3811	char *struct_offset, *tmp, name[32];
3812	bool can_augment = false;
3813	int i, cnt;
3814
3815	if (sc == NULL)
3816		return -1;
3817
3818	trace__load_vmlinux_btf(trace);
3819	if (trace->btf == NULL)
3820		return -1;
3821
3822	for (i = 0, field = sc->args; field; ++i, field = field->next) {
3823		// XXX We're only collecting pointer payloads _from_ user space
3824		if (!sc->arg_fmt[i].from_user)
3825			continue;
3826
3827		struct_offset = strstr(field->type, "struct ");
3828		if (struct_offset == NULL)
3829			struct_offset = strstr(field->type, "union ");
3830		else
3831			struct_offset++; // "union" is shorter
3832
3833		if (field->flags & TEP_FIELD_IS_POINTER && struct_offset) { /* struct or union (think BPF's attr arg) */
3834			struct_offset += 6;
3835
3836			/* for 'struct foo *', we only want 'foo' */
3837			for (tmp = struct_offset, cnt = 0; *tmp != ' ' && *tmp != '\0'; ++tmp, ++cnt) {
3838			}
3839
3840			strncpy(name, struct_offset, cnt);
3841			name[cnt] = '\0';
3842
3843			/* cache struct's btf_type and type_id */
3844			if (syscall_arg_fmt__cache_btf_struct(&sc->arg_fmt[i], trace->btf, name))
3845				continue;
3846
3847			bt = sc->arg_fmt[i].type;
3848			beauty_array[i] = bt->size;
3849			can_augment = true;
3850		} else if (field->flags & TEP_FIELD_IS_POINTER && /* string */
3851			   strcmp(field->type, "const char *") == 0 &&
3852			   (strstr(field->name, "name") ||
3853			    strstr(field->name, "path") ||
3854			    strstr(field->name, "file") ||
3855			    strstr(field->name, "root") ||
3856			    strstr(field->name, "key") ||
3857			    strstr(field->name, "special") ||
3858			    strstr(field->name, "type") ||
3859			    strstr(field->name, "description"))) {
3860			beauty_array[i] = 1;
3861			can_augment = true;
3862		} else if (field->flags & TEP_FIELD_IS_POINTER && /* buffer */
3863			   strstr(field->type, "char *") &&
3864			   (strstr(field->name, "buf") ||
3865			    strstr(field->name, "val") ||
3866			    strstr(field->name, "msg"))) {
3867			int j;
3868			struct tep_format_field *field_tmp;
3869
3870			/* find the size of the buffer that appears in pairs with buf */
3871			for (j = 0, field_tmp = sc->args; field_tmp; ++j, field_tmp = field_tmp->next) {
3872				if (!(field_tmp->flags & TEP_FIELD_IS_POINTER) && /* only integers */
3873				    (strstr(field_tmp->name, "count") ||
3874				     strstr(field_tmp->name, "siz") ||  /* size, bufsiz */
3875				     (strstr(field_tmp->name, "len") && strcmp(field_tmp->name, "filename")))) {
3876					 /* filename's got 'len' in it, we don't want that */
3877					beauty_array[i] = -(j + 1);
3878					can_augment = true;
3879					break;
3880				}
3881			}
3882		}
3883	}
3884
3885	if (can_augment)
3886		return 0;
3887
3888	return -1;
3889}
3890
3891static struct bpf_program *trace__find_usable_bpf_prog_entry(struct trace *trace,
3892							     struct syscall *sc)
3893{
3894	struct tep_format_field *field, *candidate_field;
3895	/*
3896	 * We're only interested in syscalls that have a pointer:
3897	 */
3898	for (field = sc->args; field; field = field->next) {
3899		if (field->flags & TEP_FIELD_IS_POINTER)
3900			goto try_to_find_pair;
3901	}
3902
3903	return NULL;
3904
3905try_to_find_pair:
3906	for (int i = 0, num_idx = syscalltbl__num_idx(sc->e_machine); i < num_idx; ++i) {
3907		int id = syscalltbl__id_at_idx(sc->e_machine, i);
3908		struct syscall *pair = trace__syscall_info(trace, NULL, sc->e_machine, id);
3909		struct bpf_program *pair_prog;
3910		bool is_candidate = false;
3911
3912		if (pair == NULL || pair->id == sc->id ||
3913		    pair->bpf_prog.sys_enter == unaugmented_prog)
3914			continue;
3915
3916		for (field = sc->args, candidate_field = pair->args;
3917		     field && candidate_field; field = field->next, candidate_field = candidate_field->next) {
3918			bool is_pointer = field->flags & TEP_FIELD_IS_POINTER,
3919			     candidate_is_pointer = candidate_field->flags & TEP_FIELD_IS_POINTER;
3920
3921			if (is_pointer) {
3922			       if (!candidate_is_pointer) {
3923					// The candidate just doesn't copies our pointer arg, might copy other pointers we want.
3924					continue;
3925			       }
3926			} else {
3927				if (candidate_is_pointer) {
3928					// The candidate might copy a pointer we don't have, skip it.
3929					goto next_candidate;
3930				}
3931				continue;
3932			}
3933
3934			if (strcmp(field->type, candidate_field->type))
3935				goto next_candidate;
3936
3937			/*
3938			 * This is limited in the BPF program but sys_write
3939			 * uses "const char *" for its "buf" arg so we need to
3940			 * use some heuristic that is kinda future proof...
3941			 */
3942			if (strcmp(field->type, "const char *") == 0 &&
3943			    !(strstr(field->name, "name") ||
3944			      strstr(field->name, "path") ||
3945			      strstr(field->name, "file") ||
3946			      strstr(field->name, "root") ||
3947			      strstr(field->name, "description")))
3948				goto next_candidate;
3949
3950			is_candidate = true;
3951		}
3952
3953		if (!is_candidate)
3954			goto next_candidate;
3955
3956		/*
3957		 * Check if the tentative pair syscall augmenter has more pointers, if it has,
3958		 * then it may be collecting that and we then can't use it, as it would collect
3959		 * more than what is common to the two syscalls.
3960		 */
3961		if (candidate_field) {
3962			for (candidate_field = candidate_field->next; candidate_field; candidate_field = candidate_field->next)
3963				if (candidate_field->flags & TEP_FIELD_IS_POINTER)
3964					goto next_candidate;
3965		}
3966
3967		pair_prog = pair->bpf_prog.sys_enter;
3968		/*
3969		 * If the pair isn't enabled, then its bpf_prog.sys_enter will not
3970		 * have been searched for, so search it here and if it returns the
3971		 * unaugmented one, then ignore it, otherwise we'll reuse that BPF
3972		 * program for a filtered syscall on a non-filtered one.
3973		 *
3974		 * For instance, we have "!syscalls:sys_enter_renameat" and that is
3975		 * useful for "renameat2".
3976		 */
3977		if (pair_prog == NULL) {
3978			pair_prog = trace__find_syscall_bpf_prog(trace, pair, pair->fmt ? pair->fmt->bpf_prog_name.sys_enter : NULL, "enter");
3979			if (pair_prog == unaugmented_prog)
3980				goto next_candidate;
3981		}
3982
3983		pr_debug("Reusing \"%s\" BPF sys_enter augmenter for \"%s\"\n", pair->name,
3984			 sc->name);
3985		return pair_prog;
3986	next_candidate:
3987		continue;
3988	}
3989
3990	return NULL;
3991}
3992
3993static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace, int e_machine)
3994{
3995	int map_enter_fd;
3996	int map_exit_fd;
3997	int beauty_map_fd;
3998	int err = 0;
3999	unsigned int beauty_array[6];
4000
4001	if (augmented_syscalls__get_map_fds(&map_enter_fd, &map_exit_fd, &beauty_map_fd) < 0)
4002		return -1;
4003
4004	unaugmented_prog = augmented_syscalls__unaugmented();
4005
4006	for (int i = 0, num_idx = syscalltbl__num_idx(e_machine); i < num_idx; ++i) {
4007		int prog_fd, key = syscalltbl__id_at_idx(e_machine, i);
4008
4009		if (!trace__syscall_enabled(trace, key))
4010			continue;
4011
4012		trace__init_syscall_bpf_progs(trace, e_machine, key);
4013
4014		// It'll get at least the "!raw_syscalls:unaugmented"
4015		prog_fd = trace__bpf_prog_sys_enter_fd(trace, e_machine, key);
4016		err = bpf_map_update_elem(map_enter_fd, &key, &prog_fd, BPF_ANY);
4017		if (err)
4018			break;
4019		prog_fd = trace__bpf_prog_sys_exit_fd(trace, e_machine, key);
4020		err = bpf_map_update_elem(map_exit_fd, &key, &prog_fd, BPF_ANY);
4021		if (err)
4022			break;
4023
4024		/* use beauty_map to tell BPF how many bytes to collect, set beauty_map's value here */
4025		memset(beauty_array, 0, sizeof(beauty_array));
4026		err = trace__bpf_sys_enter_beauty_map(trace, e_machine, key, (unsigned int *)beauty_array);
4027		if (err)
4028			continue;
4029		err = bpf_map_update_elem(beauty_map_fd, &key, beauty_array, BPF_ANY);
4030		if (err)
4031			break;
4032	}
4033
4034	/*
4035	 * Now lets do a second pass looking for enabled syscalls without
4036	 * an augmenter that have a signature that is a superset of another
4037	 * syscall with an augmenter so that we can auto-reuse it.
4038	 *
4039	 * I.e. if we have an augmenter for the "open" syscall that has
4040	 * this signature:
4041	 *
4042	 *   int open(const char *pathname, int flags, mode_t mode);
4043	 *
4044	 * I.e. that will collect just the first string argument, then we
4045	 * can reuse it for the 'creat' syscall, that has this signature:
4046	 *
4047	 *   int creat(const char *pathname, mode_t mode);
4048	 *
4049	 * and for:
4050	 *
4051	 *   int stat(const char *pathname, struct stat *statbuf);
4052	 *   int lstat(const char *pathname, struct stat *statbuf);
4053	 *
4054	 * Because the 'open' augmenter will collect the first arg as a string,
4055	 * and leave alone all the other args, which already helps with
4056	 * beautifying 'stat' and 'lstat''s pathname arg.
4057	 *
4058	 * Then, in time, when 'stat' gets an augmenter that collects both
4059	 * first and second arg (this one on the raw_syscalls:sys_exit prog
4060	 * array tail call, then that one will be used.
4061	 */
4062	for (int i = 0, num_idx = syscalltbl__num_idx(e_machine); i < num_idx; ++i) {
4063		int key = syscalltbl__id_at_idx(e_machine, i);
4064		struct syscall *sc = trace__syscall_info(trace, NULL, e_machine, key);
4065		struct bpf_program *pair_prog;
4066		int prog_fd;
4067
4068		if (sc == NULL || sc->bpf_prog.sys_enter == NULL)
4069			continue;
4070
4071		/*
4072		 * For now we're just reusing the sys_enter prog, and if it
4073		 * already has an augmenter, we don't need to find one.
4074		 */
4075		if (sc->bpf_prog.sys_enter != unaugmented_prog)
4076			continue;
4077
4078		/*
4079		 * Look at all the other syscalls for one that has a signature
4080		 * that is close enough that we can share:
4081		 */
4082		pair_prog = trace__find_usable_bpf_prog_entry(trace, sc);
4083		if (pair_prog == NULL)
4084			continue;
4085
4086		sc->bpf_prog.sys_enter = pair_prog;
4087
4088		/*
4089		 * Update the BPF_MAP_TYPE_PROG_SHARED for raw_syscalls:sys_enter
4090		 * with the fd for the program we're reusing:
4091		 */
4092		prog_fd = bpf_program__fd(sc->bpf_prog.sys_enter);
4093		err = bpf_map_update_elem(map_enter_fd, &key, &prog_fd, BPF_ANY);
4094		if (err)
4095			break;
4096	}
4097
4098	return err;
4099}
4100#else // !HAVE_LIBBPF_SUPPORT
4101static int trace__init_syscalls_bpf_prog_array_maps(struct trace *trace __maybe_unused,
4102						    int e_machine __maybe_unused)
4103{
4104	return -1;
4105}
4106#endif // HAVE_LIBBPF_SUPPORT
4107
4108static int trace__set_ev_qualifier_filter(struct trace *trace)
4109{
4110	if (trace->syscalls.events.sys_enter)
4111		return trace__set_ev_qualifier_tp_filter(trace);
4112	return 0;
4113}
4114
4115static int trace__set_filter_loop_pids(struct trace *trace)
4116{
4117	unsigned int nr = 1, err;
4118	pid_t pids[32] = {
4119		getpid(),
4120	};
4121	struct thread *thread = machine__find_thread(trace->host, pids[0], pids[0]);
4122
4123	while (thread && nr < ARRAY_SIZE(pids)) {
4124		struct thread *parent = machine__find_thread(trace->host,
4125							     thread__ppid(thread),
4126							     thread__ppid(thread));
4127
4128		if (parent == NULL)
4129			break;
4130
4131		if (!strcmp(thread__comm_str(parent), "sshd") ||
4132		    strstarts(thread__comm_str(parent), "gnome-terminal")) {
4133			pids[nr++] = thread__tid(parent);
4134			thread__put(parent);
4135			break;
4136		}
4137		thread__put(thread);
4138		thread = parent;
4139	}
4140	thread__put(thread);
4141
4142	err = evlist__append_tp_filter_pids(trace->evlist, nr, pids);
4143	if (!err)
4144		err = augmented_syscalls__set_filter_pids(nr, pids);
4145
4146	return err;
4147}
4148
4149static int trace__set_filter_pids(struct trace *trace)
4150{
4151	int err = 0;
4152	/*
4153	 * Better not use !target__has_task() here because we need to cover the
4154	 * case where no threads were specified in the command line, but a
4155	 * workload was, and in that case we will fill in the thread_map when
4156	 * we fork the workload in evlist__prepare_workload.
4157	 */
4158	if (trace->filter_pids.nr > 0) {
4159		err = evlist__append_tp_filter_pids(trace->evlist, trace->filter_pids.nr,
4160						    trace->filter_pids.entries);
4161		if (!err) {
4162			err = augmented_syscalls__set_filter_pids(trace->filter_pids.nr,
4163						       trace->filter_pids.entries);
4164		}
4165	} else if (perf_thread_map__pid(trace->evlist->core.threads, 0) == -1) {
4166		err = trace__set_filter_loop_pids(trace);
4167	}
4168
4169	return err;
4170}
4171
4172static int __trace__deliver_event(struct trace *trace, union perf_event *event)
4173{
4174	struct evlist *evlist = trace->evlist;
4175	struct perf_sample sample;
4176	int err;
4177
4178	perf_sample__init(&sample, /*all=*/false);
4179	err = evlist__parse_sample(evlist, event, &sample);
4180	if (err)
4181		fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
4182	else
4183		trace__handle_event(trace, event, &sample);
4184
4185	perf_sample__exit(&sample);
4186	return 0;
4187}
4188
4189static int __trace__flush_events(struct trace *trace)
4190{
4191	u64 first = ordered_events__first_time(&trace->oe.data);
4192	u64 flush = trace->oe.last - NSEC_PER_SEC;
4193
4194	/* Is there some thing to flush.. */
4195	if (first && first < flush)
4196		return ordered_events__flush_time(&trace->oe.data, flush);
4197
4198	return 0;
4199}
4200
4201static int trace__flush_events(struct trace *trace)
4202{
4203	return !trace->sort_events ? 0 : __trace__flush_events(trace);
4204}
4205
4206static int trace__deliver_event(struct trace *trace, union perf_event *event)
4207{
4208	int err;
4209
4210	if (!trace->sort_events)
4211		return __trace__deliver_event(trace, event);
4212
4213	err = evlist__parse_sample_timestamp(trace->evlist, event, &trace->oe.last);
4214	if (err && err != -1)
4215		return err;
4216
4217	err = ordered_events__queue(&trace->oe.data, event, trace->oe.last, 0, NULL);
4218	if (err)
4219		return err;
4220
4221	return trace__flush_events(trace);
4222}
4223
4224static int ordered_events__deliver_event(struct ordered_events *oe,
4225					 struct ordered_event *event)
4226{
4227	struct trace *trace = container_of(oe, struct trace, oe.data);
4228
4229	return __trace__deliver_event(trace, event->event);
4230}
4231
4232static struct syscall_arg_fmt *evsel__find_syscall_arg_fmt_by_name(struct evsel *evsel, char *arg,
4233								   char **type)
4234{
4235	struct syscall_arg_fmt *fmt = __evsel__syscall_arg_fmt(evsel);
4236	const struct tep_event *tp_format;
4237
4238	if (!fmt)
4239		return NULL;
4240
4241	tp_format = evsel__tp_format(evsel);
4242	if (!tp_format)
4243		return NULL;
4244
4245	for (const struct tep_format_field *field = tp_format->format.fields; field;
4246	     field = field->next, ++fmt) {
4247		if (strcmp(field->name, arg) == 0) {
4248			*type = field->type;
4249			return fmt;
4250		}
4251	}
4252
4253	return NULL;
4254}
4255
4256static int trace__expand_filter(struct trace *trace, struct evsel *evsel)
4257{
4258	char *tok, *left = evsel->filter, *new_filter = evsel->filter;
4259
4260	while ((tok = strpbrk(left, "=<>!")) != NULL) {
4261		char *right = tok + 1, *right_end;
4262
4263		if (*right == '=')
4264			++right;
4265
4266		while (isspace(*right))
4267			++right;
4268
4269		if (*right == '\0')
4270			break;
4271
4272		while (!isalpha(*left))
4273			if (++left == tok) {
4274				/*
4275				 * Bail out, can't find the name of the argument that is being
4276				 * used in the filter, let it try to set this filter, will fail later.
4277				 */
4278				return 0;
4279			}
4280
4281		right_end = right + 1;
4282		while (isalnum(*right_end) || *right_end == '_' || *right_end == '|')
4283			++right_end;
4284
4285		if (isalpha(*right)) {
4286			struct syscall_arg_fmt *fmt;
4287			int left_size = tok - left,
4288			    right_size = right_end - right;
4289			char arg[128], *type;
4290
4291			while (isspace(left[left_size - 1]))
4292				--left_size;
4293
4294			scnprintf(arg, sizeof(arg), "%.*s", left_size, left);
4295
4296			fmt = evsel__find_syscall_arg_fmt_by_name(evsel, arg, &type);
4297			if (fmt == NULL) {
4298				pr_err("\"%s\" not found in \"%s\", can't set filter \"%s\"\n",
4299				       arg, evsel->name, evsel->filter);
4300				return -1;
4301			}
4302
4303			pr_debug2("trying to expand \"%s\" \"%.*s\" \"%.*s\" -> ",
4304				 arg, (int)(right - tok), tok, right_size, right);
4305
4306			if (fmt->strtoul) {
4307				u64 val;
4308				struct syscall_arg syscall_arg = {
4309					.trace = trace,
4310					.fmt   = fmt,
4311					.type_name = type,
4312					.parm = fmt->parm,
4313				};
4314
4315				if (fmt->strtoul(right, right_size, &syscall_arg, &val)) {
4316					char *n, expansion[19];
4317					int expansion_lenght = scnprintf(expansion, sizeof(expansion), "%#" PRIx64, val);
4318					int expansion_offset = right - new_filter;
4319
4320					pr_debug("%s", expansion);
4321
4322					if (asprintf(&n, "%.*s%s%s", expansion_offset, new_filter, expansion, right_end) < 0) {
4323						pr_debug(" out of memory!\n");
4324						free(new_filter);
4325						return -1;
4326					}
4327					if (new_filter != evsel->filter)
4328						free(new_filter);
4329					left = n + expansion_offset + expansion_lenght;
4330					new_filter = n;
4331				} else {
4332					pr_err("\"%.*s\" not found for \"%s\" in \"%s\", can't set filter \"%s\"\n",
4333					       right_size, right, arg, evsel->name, evsel->filter);
4334					return -1;
4335				}
4336			} else {
4337				pr_err("No resolver (strtoul) for \"%s\" in \"%s\", can't set filter \"%s\"\n",
4338				       arg, evsel->name, evsel->filter);
4339				return -1;
4340			}
4341
4342			pr_debug("\n");
4343		} else {
4344			left = right_end;
4345		}
4346	}
4347
4348	if (new_filter != evsel->filter) {
4349		pr_debug("New filter for %s: %s\n", evsel->name, new_filter);
4350		evsel__set_filter(evsel, new_filter);
4351		free(new_filter);
4352	}
4353
4354	return 0;
4355}
4356
4357static int trace__expand_filters(struct trace *trace, struct evsel **err_evsel)
4358{
4359	struct evlist *evlist = trace->evlist;
4360	struct evsel *evsel;
4361
4362	evlist__for_each_entry(evlist, evsel) {
4363		if (evsel->filter == NULL)
4364			continue;
4365
4366		if (trace__expand_filter(trace, evsel)) {
4367			*err_evsel = evsel;
4368			return -1;
4369		}
4370	}
4371
4372	return 0;
4373}
4374
4375static int trace__run(struct trace *trace, int argc, const char **argv)
4376{
4377	struct evlist *evlist = trace->evlist;
4378	struct evsel *evsel, *pgfault_maj = NULL, *pgfault_min = NULL;
4379	int err = -1, i;
4380	unsigned long before;
4381	const bool forks = argc > 0;
4382	bool draining = false;
4383
4384	trace->live = true;
4385
4386	if (trace->summary_bpf) {
4387		if (trace_prepare_bpf_summary(trace->summary_mode) < 0)
4388			goto out_delete_evlist;
4389
4390		if (trace->summary_only)
4391			goto create_maps;
4392	}
4393
4394	if (!trace->raw_augmented_syscalls) {
4395		if (trace->trace_syscalls && trace__add_syscall_newtp(trace))
4396			goto out_error_raw_syscalls;
4397
4398		if (trace->trace_syscalls)
4399			trace->vfs_getname = evlist__add_vfs_getname(evlist);
4400	}
4401
4402	if ((trace->trace_pgfaults & TRACE_PFMAJ)) {
4403		pgfault_maj = evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MAJ);
4404		if (pgfault_maj == NULL)
4405			goto out_error_mem;
4406		evsel__config_callchain(pgfault_maj, &trace->opts, &callchain_param);
4407		evlist__add(evlist, pgfault_maj);
4408	}
4409
4410	if ((trace->trace_pgfaults & TRACE_PFMIN)) {
4411		pgfault_min = evsel__new_pgfault(PERF_COUNT_SW_PAGE_FAULTS_MIN);
4412		if (pgfault_min == NULL)
4413			goto out_error_mem;
4414		evsel__config_callchain(pgfault_min, &trace->opts, &callchain_param);
4415		evlist__add(evlist, pgfault_min);
4416	}
4417
4418	/* Enable ignoring missing threads when -p option is defined. */
4419	trace->opts.ignore_missing_thread = trace->opts.target.pid;
4420
4421	if (trace->sched &&
4422	    evlist__add_newtp(evlist, "sched", "sched_stat_runtime", trace__sched_stat_runtime))
4423		goto out_error_sched_stat_runtime;
4424	/*
4425	 * If a global cgroup was set, apply it to all the events without an
4426	 * explicit cgroup. I.e.:
4427	 *
4428	 * 	trace -G A -e sched:*switch
4429	 *
4430	 * Will set all raw_syscalls:sys_{enter,exit}, pgfault, vfs_getname, etc
4431	 * _and_ sched:sched_switch to the 'A' cgroup, while:
4432	 *
4433	 * trace -e sched:*switch -G A
4434	 *
4435	 * will only set the sched:sched_switch event to the 'A' cgroup, all the
4436	 * other events (raw_syscalls:sys_{enter,exit}, etc are left "without"
4437	 * a cgroup (on the root cgroup, sys wide, etc).
4438	 *
4439	 * Multiple cgroups:
4440	 *
4441	 * trace -G A -e sched:*switch -G B
4442	 *
4443	 * the syscall ones go to the 'A' cgroup, the sched:sched_switch goes
4444	 * to the 'B' cgroup.
4445	 *
4446	 * evlist__set_default_cgroup() grabs a reference of the passed cgroup
4447	 * only for the evsels still without a cgroup, i.e. evsel->cgroup == NULL.
4448	 */
4449	if (trace->cgroup)
4450		evlist__set_default_cgroup(trace->evlist, trace->cgroup);
4451
4452create_maps:
4453	err = evlist__create_maps(evlist, &trace->opts.target);
4454	if (err < 0) {
4455		fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
4456		goto out_delete_evlist;
4457	}
4458
4459	err = trace__symbols_init(trace, argc, argv, evlist);
4460	if (err < 0) {
4461		fprintf(trace->output, "Problems initializing symbol libraries!\n");
4462		goto out_delete_evlist;
4463	}
4464
4465	if (trace->summary_mode == SUMMARY__BY_TOTAL && !trace->summary_bpf) {
4466		trace->syscall_stats = alloc_syscall_stats();
4467		if (IS_ERR(trace->syscall_stats))
4468			goto out_delete_evlist;
4469	}
4470
4471	evlist__config(evlist, &trace->opts, &callchain_param);
4472
4473	if (forks) {
4474		err = evlist__prepare_workload(evlist, &trace->opts.target, argv, false, NULL);
4475		if (err < 0) {
4476			fprintf(trace->output, "Couldn't run the workload!\n");
4477			goto out_delete_evlist;
4478		}
4479		workload_pid = evlist->workload.pid;
4480	}
4481
4482	err = evlist__open(evlist);
4483	if (err < 0)
4484		goto out_error_open;
4485
4486	augmented_syscalls__setup_bpf_output();
4487
4488	err = trace__set_filter_pids(trace);
4489	if (err < 0)
4490		goto out_error_mem;
4491
4492	/*
4493	 * TODO: Initialize for all host binary machine types, not just
4494	 * those matching the perf binary.
4495	 */
4496	trace__init_syscalls_bpf_prog_array_maps(trace, EM_HOST);
4497
4498	if (trace->ev_qualifier_ids.nr > 0) {
4499		err = trace__set_ev_qualifier_filter(trace);
4500		if (err < 0)
4501			goto out_errno;
4502
4503		if (trace->syscalls.events.sys_exit) {
4504			pr_debug("event qualifier tracepoint filter: %s\n",
4505				 trace->syscalls.events.sys_exit->filter);
4506		}
4507	}
4508
4509	/*
4510	 * If the "close" syscall is not traced, then we will not have the
4511	 * opportunity to, in syscall_arg__scnprintf_close_fd() invalidate the
4512	 * fd->pathname table and were ending up showing the last value set by
4513	 * syscalls opening a pathname and associating it with a descriptor or
4514	 * reading it from /proc/pid/fd/ in cases where that doesn't make
4515	 * sense.
4516	 *
4517	 *  So just disable this beautifier (SCA_FD, SCA_FDAT) when 'close' is
4518	 *  not in use.
4519	 */
4520	/* TODO: support for more than just perf binary machine type close. */
4521	trace->fd_path_disabled = !trace__syscall_enabled(trace, syscalltbl__id(EM_HOST, "close"));
4522
4523	err = trace__expand_filters(trace, &evsel);
4524	if (err)
4525		goto out_delete_evlist;
4526	err = evlist__apply_filters(evlist, &evsel, &trace->opts.target);
4527	if (err < 0)
4528		goto out_error_apply_filters;
4529
4530	if (!trace->summary_only || !trace->summary_bpf) {
4531		err = evlist__mmap(evlist, trace->opts.mmap_pages);
4532		if (err < 0)
4533			goto out_error_mmap;
4534	}
4535
4536	if (!target__none(&trace->opts.target) && !trace->opts.target.initial_delay)
4537		evlist__enable(evlist);
4538
4539	if (forks)
4540		evlist__start_workload(evlist);
4541
4542	if (trace->opts.target.initial_delay) {
4543		usleep(trace->opts.target.initial_delay * 1000);
4544		evlist__enable(evlist);
4545	}
4546
4547	if (trace->summary_bpf)
4548		trace_start_bpf_summary();
4549
4550	trace->multiple_threads = perf_thread_map__pid(evlist->core.threads, 0) == -1 ||
4551		perf_thread_map__nr(evlist->core.threads) > 1 ||
4552		evlist__first(evlist)->core.attr.inherit;
4553
4554	/*
4555	 * Now that we already used evsel->core.attr to ask the kernel to setup the
4556	 * events, lets reuse evsel->core.attr.sample_max_stack as the limit in
4557	 * trace__resolve_callchain(), allowing per-event max-stack settings
4558	 * to override an explicitly set --max-stack global setting.
4559	 */
4560	evlist__for_each_entry(evlist, evsel) {
4561		if (evsel__has_callchain(evsel) &&
4562		    evsel->core.attr.sample_max_stack == 0)
4563			evsel->core.attr.sample_max_stack = trace->max_stack;
4564	}
4565again:
4566	before = trace->nr_events;
4567
4568	for (i = 0; i < evlist->core.nr_mmaps; i++) {
4569		union perf_event *event;
4570		struct mmap *md;
4571
4572		md = &evlist->mmap[i];
4573		if (perf_mmap__read_init(&md->core) < 0)
4574			continue;
4575
4576		while ((event = perf_mmap__read_event(&md->core)) != NULL) {
4577			++trace->nr_events;
4578
4579			err = trace__deliver_event(trace, event);
4580			if (err)
4581				goto out_disable;
4582
4583			perf_mmap__consume(&md->core);
4584
4585			if (interrupted)
4586				goto out_disable;
4587
4588			if (done && !draining) {
4589				evlist__disable(evlist);
4590				draining = true;
4591			}
4592		}
4593		perf_mmap__read_done(&md->core);
4594	}
4595
4596	if (trace->nr_events == before) {
4597		int timeout = done ? 100 : -1;
4598
4599		if (!draining && evlist__poll(evlist, timeout) > 0) {
4600			if (evlist__filter_pollfd(evlist, POLLERR | POLLHUP | POLLNVAL) == 0)
4601				draining = true;
4602
4603			goto again;
4604		} else {
4605			if (trace__flush_events(trace))
4606				goto out_disable;
4607		}
4608	} else {
4609		goto again;
4610	}
4611
4612out_disable:
4613	thread__zput(trace->current);
4614
4615	evlist__disable(evlist);
4616
4617	if (trace->summary_bpf)
4618		trace_end_bpf_summary();
4619
4620	if (trace->sort_events)
4621		ordered_events__flush(&trace->oe.data, OE_FLUSH__FINAL);
4622
4623	if (!err) {
4624		if (trace->summary) {
4625			if (trace->summary_bpf)
4626				trace_print_bpf_summary(trace->output, trace->max_summary);
4627			else if (trace->summary_mode == SUMMARY__BY_TOTAL)
4628				trace__fprintf_total_summary(trace, trace->output);
4629			else
4630				trace__fprintf_thread_summary(trace, trace->output);
4631		}
4632
4633		if (trace->show_tool_stats) {
4634			fprintf(trace->output, "Stats:\n "
4635					       " vfs_getname : %" PRIu64 "\n"
4636					       " proc_getname: %" PRIu64 "\n",
4637				trace->stats.vfs_getname,
4638				trace->stats.proc_getname);
4639		}
4640	}
4641
4642out_delete_evlist:
4643	trace_cleanup_bpf_summary();
4644	delete_syscall_stats(trace->syscall_stats);
4645	trace__symbols__exit(trace);
4646	evlist__free_syscall_tp_fields(evlist);
4647	evlist__delete(evlist);
4648	cgroup__put(trace->cgroup);
4649	trace->evlist = NULL;
4650	trace->live = false;
4651	return err;
4652{
4653	char errbuf[BUFSIZ];
4654
4655out_error_sched_stat_runtime:
4656	tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "sched", "sched_stat_runtime");
4657	goto out_error;
4658
4659out_error_raw_syscalls:
4660	tracing_path__strerror_open_tp(errno, errbuf, sizeof(errbuf), "raw_syscalls", "sys_(enter|exit)");
4661	goto out_error;
4662
4663out_error_mmap:
4664	evlist__strerror_mmap(evlist, errno, errbuf, sizeof(errbuf));
4665	goto out_error;
4666
4667out_error_open:
4668	evlist__strerror_open(evlist, errno, errbuf, sizeof(errbuf));
4669
4670out_error:
4671	fprintf(trace->output, "%s\n", errbuf);
4672	goto out_delete_evlist;
4673
4674out_error_apply_filters:
4675	fprintf(trace->output,
4676		"Failed to set filter \"%s\" on event %s with %d (%s)\n",
4677		evsel->filter, evsel__name(evsel), errno,
4678		str_error_r(errno, errbuf, sizeof(errbuf)));
4679	goto out_delete_evlist;
4680}
4681out_error_mem:
4682	fprintf(trace->output, "Not enough memory to run!\n");
4683	goto out_delete_evlist;
4684
4685out_errno:
4686	fprintf(trace->output, "errno=%d,%s\n", errno, strerror(errno));
4687	goto out_delete_evlist;
4688}
4689
4690static int trace__replay(struct trace *trace)
4691{
4692	const struct evsel_str_handler handlers[] = {
4693		{ "probe:vfs_getname",	     trace__vfs_getname, },
4694	};
4695	struct perf_data data = {
4696		.path  = input_name,
4697		.mode  = PERF_DATA_MODE_READ,
4698		.force = trace->force,
4699	};
4700	struct perf_session *session;
4701	struct evsel *evsel;
4702	int err = -1;
4703
4704	perf_tool__init(&trace->tool, /*ordered_events=*/true);
4705	trace->tool.sample	  = trace__process_sample;
4706	trace->tool.mmap	  = perf_event__process_mmap;
4707	trace->tool.mmap2	  = perf_event__process_mmap2;
4708	trace->tool.comm	  = perf_event__process_comm;
4709	trace->tool.exit	  = perf_event__process_exit;
4710	trace->tool.fork	  = perf_event__process_fork;
4711	trace->tool.attr	  = perf_event__process_attr;
4712	trace->tool.tracing_data  = perf_event__process_tracing_data;
4713	trace->tool.build_id	  = perf_event__process_build_id;
4714	trace->tool.namespaces	  = perf_event__process_namespaces;
4715
4716	trace->tool.ordered_events = true;
4717	trace->tool.ordering_requires_timestamps = true;
4718
4719	/* add tid to output */
4720	trace->multiple_threads = true;
4721
4722	session = perf_session__new(&data, &trace->tool);
4723	if (IS_ERR(session))
4724		return PTR_ERR(session);
4725
4726	if (trace->opts.target.pid)
4727		symbol_conf.pid_list_str = strdup(trace->opts.target.pid);
4728
4729	if (trace->opts.target.tid)
4730		symbol_conf.tid_list_str = strdup(trace->opts.target.tid);
4731
4732	if (symbol__init(perf_session__env(session)) < 0)
4733		goto out;
4734
4735	trace->host = &session->machines.host;
4736
4737	err = perf_session__set_tracepoints_handlers(session, handlers);
4738	if (err)
4739		goto out;
4740
4741	evsel = evlist__find_tracepoint_by_name(session->evlist, "raw_syscalls:sys_enter");
4742	trace->syscalls.events.sys_enter = evsel;
4743	/* older kernels have syscalls tp versus raw_syscalls */
4744	if (evsel == NULL)
4745		evsel = evlist__find_tracepoint_by_name(session->evlist, "syscalls:sys_enter");
4746
4747	if (evsel &&
4748	    (evsel__init_raw_syscall_tp(evsel, trace__sys_enter) < 0 ||
4749	    perf_evsel__init_sc_tp_ptr_field(evsel, args))) {
4750		pr_err("Error during initialize raw_syscalls:sys_enter event\n");
4751		goto out;
4752	}
4753
4754	evsel = evlist__find_tracepoint_by_name(session->evlist, "raw_syscalls:sys_exit");
4755	trace->syscalls.events.sys_exit = evsel;
4756	if (evsel == NULL)
4757		evsel = evlist__find_tracepoint_by_name(session->evlist, "syscalls:sys_exit");
4758	if (evsel &&
4759	    (evsel__init_raw_syscall_tp(evsel, trace__sys_exit) < 0 ||
4760	    perf_evsel__init_sc_tp_uint_field(evsel, ret))) {
4761		pr_err("Error during initialize raw_syscalls:sys_exit event\n");
4762		goto out;
4763	}
4764
4765	evlist__for_each_entry(session->evlist, evsel) {
4766		if (evsel->core.attr.type == PERF_TYPE_SOFTWARE &&
4767		    (evsel->core.attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
4768		     evsel->core.attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
4769		     evsel->core.attr.config == PERF_COUNT_SW_PAGE_FAULTS))
4770			evsel->handler = trace__pgfault;
4771	}
4772
4773	if (trace->summary_mode == SUMMARY__BY_TOTAL) {
4774		trace->syscall_stats = alloc_syscall_stats();
4775		if (IS_ERR(trace->syscall_stats))
4776			goto out;
4777	}
4778
4779	setup_pager();
4780
4781	err = perf_session__process_events(session);
4782	if (err)
4783		pr_err("Failed to process events, error %d", err);
4784
4785	else if (trace->summary)
4786		trace__fprintf_thread_summary(trace, trace->output);
4787
4788out:
4789	delete_syscall_stats(trace->syscall_stats);
4790	perf_session__delete(session);
4791
4792	return err;
4793}
4794
4795static size_t trace__fprintf_summary_header(FILE *fp)
4796{
4797	size_t printed;
4798
4799	printed  = fprintf(fp, "\n Summary of events:\n\n");
4800
4801	return printed;
4802}
4803
4804struct syscall_entry {
4805	struct syscall_stats *stats;
4806	double		     msecs;
4807	int		     syscall;
4808};
4809
4810static int entry_cmp(const void *e1, const void *e2)
4811{
4812	const struct syscall_entry *entry1 = e1;
4813	const struct syscall_entry *entry2 = e2;
4814
4815	return entry1->msecs > entry2->msecs ? -1 : 1;
4816}
4817
4818static struct syscall_entry *syscall__sort_stats(struct hashmap *syscall_stats)
4819{
4820	struct syscall_entry *entry;
4821	struct hashmap_entry *pos;
4822	unsigned bkt, i, nr;
4823
4824	nr = syscall_stats->sz;
4825	entry = malloc(nr * sizeof(*entry));
4826	if (entry == NULL)
4827		return NULL;
4828
4829	i = 0;
4830	hashmap__for_each_entry(syscall_stats, pos, bkt) {
4831		struct syscall_stats *ss = pos->pvalue;
4832		struct stats *st = &ss->stats;
4833
4834		entry[i].stats = ss;
4835		entry[i].msecs = (u64)st->n * (avg_stats(st) / NSEC_PER_MSEC);
4836		entry[i].syscall = pos->key;
4837		i++;
4838	}
4839	assert(i == nr);
4840
4841	qsort(entry, nr, sizeof(*entry), entry_cmp);
4842	return entry;
4843}
4844
4845static size_t syscall__dump_stats(struct trace *trace, int e_machine, FILE *fp,
4846				  struct hashmap *syscall_stats)
4847{
4848	size_t printed = 0;
4849	int lines = 0;
4850	struct syscall *sc;
4851	struct syscall_entry *entries;
4852
4853	entries = syscall__sort_stats(syscall_stats);
4854	if (entries == NULL)
4855		return 0;
4856
4857	printed += fprintf(fp, "\n");
4858
4859	printed += fprintf(fp, "   syscall            calls  errors  total       min       avg       max       stddev\n");
4860	printed += fprintf(fp, "                                     (msec)    (msec)    (msec)    (msec)        (%%)\n");
4861	printed += fprintf(fp, "   --------------- --------  ------ -------- --------- --------- ---------     ------\n");
4862
4863	for (size_t i = 0; i < syscall_stats->sz; i++) {
4864		struct syscall_entry *entry = &entries[i];
4865		struct syscall_stats *stats = entry->stats;
4866
4867		if (stats) {
4868			double min = (double)(stats->stats.min) / NSEC_PER_MSEC;
4869			double max = (double)(stats->stats.max) / NSEC_PER_MSEC;
4870			double avg = avg_stats(&stats->stats);
4871			double pct;
4872			u64 n = (u64)stats->stats.n;
4873
4874			pct = avg ? 100.0 * stddev_stats(&stats->stats) / avg : 0.0;
4875			avg /= NSEC_PER_MSEC;
4876
4877			sc = trace__syscall_info(trace, /*evsel=*/NULL, e_machine, entry->syscall);
4878			if (!sc)
4879				continue;
4880
4881			printed += fprintf(fp, "   %-15s", sc->name);
4882			printed += fprintf(fp, " %8" PRIu64 " %6" PRIu64 " %9.3f %9.3f %9.3f",
4883					   n, stats->nr_failures, entry->msecs, min, avg);
4884			printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
4885
4886			if (trace->errno_summary && stats->nr_failures) {
4887				int e;
4888
4889				for (e = 0; e < stats->max_errno; ++e) {
4890					if (stats->errnos[e] != 0)
4891						fprintf(fp, "\t\t\t\t%s: %d\n", perf_env__arch_strerrno(trace->host->env, e + 1), stats->errnos[e]);
4892				}
4893			}
4894			lines++;
4895		}
4896
4897		if (trace->max_summary && trace->max_summary <= lines)
4898			break;
4899	}
4900
4901	free(entries);
4902	printed += fprintf(fp, "\n\n");
4903
4904	return printed;
4905}
4906
4907static size_t thread__dump_stats(struct thread_trace *ttrace,
4908				 struct trace *trace, int e_machine, FILE *fp)
4909{
4910	return syscall__dump_stats(trace, e_machine, fp, ttrace->syscall_stats);
4911}
4912
4913static size_t system__dump_stats(struct trace *trace, int e_machine, FILE *fp)
4914{
4915	return syscall__dump_stats(trace, e_machine, fp, trace->syscall_stats);
4916}
4917
4918static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
4919{
4920	size_t printed = 0;
4921	struct thread_trace *ttrace = thread__priv(thread);
4922	int e_machine = thread__e_machine(thread, trace->host);
4923	double ratio;
4924
4925	if (ttrace == NULL)
4926		return 0;
4927
4928	ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
4929
4930	printed += fprintf(fp, " %s (%d), ", thread__comm_str(thread), thread__tid(thread));
4931	printed += fprintf(fp, "%lu events, ", ttrace->nr_events);
4932	printed += fprintf(fp, "%.1f%%", ratio);
4933	if (ttrace->pfmaj)
4934		printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
4935	if (ttrace->pfmin)
4936		printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
4937	if (trace->sched)
4938		printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
4939	else if (fputc('\n', fp) != EOF)
4940		++printed;
4941
4942	printed += thread__dump_stats(ttrace, trace, e_machine, fp);
4943
4944	return printed;
4945}
4946
4947static unsigned long thread__nr_events(struct thread_trace *ttrace)
4948{
4949	return ttrace ? ttrace->nr_events : 0;
4950}
4951
4952static int trace_nr_events_cmp(void *priv __maybe_unused,
4953			       const struct list_head *la,
4954			       const struct list_head *lb)
4955{
4956	struct thread_list *a = list_entry(la, struct thread_list, list);
4957	struct thread_list *b = list_entry(lb, struct thread_list, list);
4958	unsigned long a_nr_events = thread__nr_events(thread__priv(a->thread));
4959	unsigned long b_nr_events = thread__nr_events(thread__priv(b->thread));
4960
4961	if (a_nr_events != b_nr_events)
4962		return a_nr_events < b_nr_events ? -1 : 1;
4963
4964	/* Identical number of threads, place smaller tids first. */
4965	return thread__tid(a->thread) < thread__tid(b->thread)
4966		? -1
4967		: (thread__tid(a->thread) > thread__tid(b->thread) ? 1 : 0);
4968}
4969
4970static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
4971{
4972	size_t printed = trace__fprintf_summary_header(fp);
4973	LIST_HEAD(threads);
4974
4975	if (machine__thread_list(trace->host, &threads) == 0) {
4976		struct thread_list *pos;
4977
4978		list_sort(NULL, &threads, trace_nr_events_cmp);
4979
4980		list_for_each_entry(pos, &threads, list)
4981			printed += trace__fprintf_thread(fp, pos->thread, trace);
4982	}
4983	thread_list__delete(&threads);
4984	return printed;
4985}
4986
4987static size_t trace__fprintf_total_summary(struct trace *trace, FILE *fp)
4988{
4989	size_t printed = trace__fprintf_summary_header(fp);
4990
4991	printed += fprintf(fp, " total, ");
4992	printed += fprintf(fp, "%lu events", trace->nr_events);
4993
4994	if (trace->pfmaj)
4995		printed += fprintf(fp, ", %lu majfaults", trace->pfmaj);
4996	if (trace->pfmin)
4997		printed += fprintf(fp, ", %lu minfaults", trace->pfmin);
4998	if (trace->sched)
4999		printed += fprintf(fp, ", %.3f msec\n", trace->runtime_ms);
5000	else if (fputc('\n', fp) != EOF)
5001		++printed;
5002
5003	/* TODO: get all system e_machines. */
5004	printed += system__dump_stats(trace, EM_HOST, fp);
5005
5006	return printed;
5007}
5008
5009static int trace__set_duration(const struct option *opt, const char *str,
5010			       int unset __maybe_unused)
5011{
5012	struct trace *trace = opt->value;
5013
5014	trace->duration_filter = atof(str);
5015	return 0;
5016}
5017
5018static int trace__set_filter_pids_from_option(const struct option *opt, const char *str,
5019					      int unset __maybe_unused)
5020{
5021	int ret = -1;
5022	size_t i;
5023	struct trace *trace = opt->value;
5024	/*
5025	 * FIXME: introduce a intarray class, plain parse csv and create a
5026	 * { int nr, int entries[] } struct...
5027	 */
5028	struct intlist *list = intlist__new(str);
5029
5030	if (list == NULL)
5031		return -1;
5032
5033	i = trace->filter_pids.nr = intlist__nr_entries(list) + 1;
5034	trace->filter_pids.entries = calloc(i, sizeof(pid_t));
5035
5036	if (trace->filter_pids.entries == NULL)
5037		goto out;
5038
5039	trace->filter_pids.entries[0] = getpid();
5040
5041	for (i = 1; i < trace->filter_pids.nr; ++i)
5042		trace->filter_pids.entries[i] = intlist__entry(list, i - 1)->i;
5043
5044	intlist__delete(list);
5045	ret = 0;
5046out:
5047	return ret;
5048}
5049
5050static int trace__open_output(struct trace *trace, const char *filename)
5051{
5052	struct stat st;
5053
5054	if (!stat(filename, &st) && st.st_size) {
5055		char oldname[PATH_MAX];
5056
5057		scnprintf(oldname, sizeof(oldname), "%s.old", filename);
5058		unlink(oldname);
5059		rename(filename, oldname);
5060	}
5061
5062	trace->output = fopen(filename, "w");
5063
5064	return trace->output == NULL ? -errno : 0;
5065}
5066
5067static int parse_pagefaults(const struct option *opt, const char *str,
5068			    int unset __maybe_unused)
5069{
5070	int *trace_pgfaults = opt->value;
5071
5072	if (strcmp(str, "all") == 0)
5073		*trace_pgfaults |= TRACE_PFMAJ | TRACE_PFMIN;
5074	else if (strcmp(str, "maj") == 0)
5075		*trace_pgfaults |= TRACE_PFMAJ;
5076	else if (strcmp(str, "min") == 0)
5077		*trace_pgfaults |= TRACE_PFMIN;
5078	else
5079		return -1;
5080
5081	return 0;
5082}
5083
5084static void evlist__set_default_evsel_handler(struct evlist *evlist, void *handler)
5085{
5086	struct evsel *evsel;
5087
5088	evlist__for_each_entry(evlist, evsel) {
5089		if (evsel->handler == NULL)
5090			evsel->handler = handler;
5091	}
5092}
5093
5094static void evsel__set_syscall_arg_fmt(struct evsel *evsel, const char *name)
5095{
5096	struct syscall_arg_fmt *fmt = evsel__syscall_arg_fmt(evsel);
5097
5098	if (fmt) {
5099		const struct syscall_fmt *scfmt = syscall_fmt__find(name);
5100
5101		if (scfmt) {
5102			const struct tep_event *tp_format = evsel__tp_format(evsel);
5103
5104			if (tp_format) {
5105				int skip = 0;
5106
5107				if (strcmp(tp_format->format.fields->name, "__syscall_nr") == 0 ||
5108				    strcmp(tp_format->format.fields->name, "nr") == 0)
5109					++skip;
5110
5111				memcpy(fmt + skip, scfmt->arg,
5112				       (tp_format->format.nr_fields - skip) * sizeof(*fmt));
5113			}
5114		}
5115	}
5116}
5117
5118static int evlist__set_syscall_tp_fields(struct evlist *evlist, bool *use_btf)
5119{
5120	struct evsel *evsel;
5121
5122	evlist__for_each_entry(evlist, evsel) {
5123		const struct tep_event *tp_format;
5124
5125		if (evsel->priv)
5126			continue;
5127
5128		tp_format = evsel__tp_format(evsel);
5129		if (!tp_format)
5130			continue;
5131
5132		if (strcmp(tp_format->system, "syscalls")) {
5133			evsel__init_tp_arg_scnprintf(evsel, use_btf);
5134			continue;
5135		}
5136
5137		if (evsel__init_syscall_tp(evsel))
5138			return -1;
5139
5140		if (!strncmp(tp_format->name, "sys_enter_", 10)) {
5141			struct syscall_tp *sc = __evsel__syscall_tp(evsel);
5142
5143			if (__tp_field__init_ptr(&sc->args, sc->id.offset + sizeof(u64)))
5144				return -1;
5145
5146			evsel__set_syscall_arg_fmt(evsel,
5147						   tp_format->name + sizeof("sys_enter_") - 1);
5148		} else if (!strncmp(tp_format->name, "sys_exit_", 9)) {
5149			struct syscall_tp *sc = __evsel__syscall_tp(evsel);
5150
5151			if (__tp_field__init_uint(&sc->ret, sizeof(u64),
5152						  sc->id.offset + sizeof(u64),
5153						  evsel->needs_swap))
5154				return -1;
5155
5156			evsel__set_syscall_arg_fmt(evsel,
5157						   tp_format->name + sizeof("sys_exit_") - 1);
5158		}
5159	}
5160
5161	return 0;
5162}
5163
5164/*
5165 * XXX: Hackish, just splitting the combined -e+--event (syscalls
5166 * (raw_syscalls:{sys_{enter,exit}} + events (tracepoints, HW, SW, etc) to use
5167 * existing facilities unchanged (trace->ev_qualifier + parse_options()).
5168 *
5169 * It'd be better to introduce a parse_options() variant that would return a
5170 * list with the terms it didn't match to an event...
5171 */
5172static int trace__parse_events_option(const struct option *opt, const char *str,
5173				      int unset __maybe_unused)
5174{
5175	struct trace *trace = (struct trace *)opt->value;
5176	const char *s = str;
5177	char *sep = NULL, *lists[2] = { NULL, NULL, };
5178	int len = strlen(str) + 1, err = -1, list, idx;
5179	char *strace_groups_dir = system_path(STRACE_GROUPS_DIR);
5180	char group_name[PATH_MAX];
5181	const struct syscall_fmt *fmt;
5182
5183	if (strace_groups_dir == NULL)
5184		return -1;
5185
5186	if (*s == '!') {
5187		++s;
5188		trace->not_ev_qualifier = true;
5189	}
5190
5191	while (1) {
5192		if ((sep = strchr(s, ',')) != NULL)
5193			*sep = '\0';
5194
5195		list = 0;
5196		/* TODO: support for more than just perf binary machine type syscalls. */
5197		if (syscalltbl__id(EM_HOST, s) >= 0 ||
5198		    syscalltbl__strglobmatch_first(EM_HOST, s, &idx) >= 0) {
5199			list = 1;
5200			goto do_concat;
5201		}
5202
5203		fmt = syscall_fmt__find_by_alias(s);
5204		if (fmt != NULL) {
5205			list = 1;
5206			s = fmt->name;
5207		} else {
5208			path__join(group_name, sizeof(group_name), strace_groups_dir, s);
5209			if (access(group_name, R_OK) == 0)
5210				list = 1;
5211		}
5212do_concat:
5213		if (lists[list]) {
5214			sprintf(lists[list] + strlen(lists[list]), ",%s", s);
5215		} else {
5216			lists[list] = malloc(len);
5217			if (lists[list] == NULL)
5218				goto out;
5219			strcpy(lists[list], s);
5220		}
5221
5222		if (!sep)
5223			break;
5224
5225		*sep = ',';
5226		s = sep + 1;
5227	}
5228
5229	if (lists[1] != NULL) {
5230		struct strlist_config slist_config = {
5231			.dirname = strace_groups_dir,
5232		};
5233
5234		trace->ev_qualifier = strlist__new(lists[1], &slist_config);
5235		if (trace->ev_qualifier == NULL) {
5236			fputs("Not enough memory to parse event qualifier", trace->output);
5237			goto out;
5238		}
5239
5240		if (trace__validate_ev_qualifier(trace))
5241			goto out;
5242		trace->trace_syscalls = true;
5243	}
5244
5245	err = 0;
5246
5247	if (lists[0]) {
5248		struct parse_events_option_args parse_events_option_args = {
5249			.evlistp = &trace->evlist,
5250		};
5251		struct option o = {
5252			.value = &parse_events_option_args,
5253		};
5254		err = parse_events_option(&o, lists[0], 0);
5255	}
5256out:
5257	free(strace_groups_dir);
5258	free(lists[0]);
5259	free(lists[1]);
5260	if (sep)
5261		*sep = ',';
5262
5263	return err;
5264}
5265
5266static int trace__parse_cgroups(const struct option *opt, const char *str, int unset)
5267{
5268	struct trace *trace = opt->value;
5269
5270	if (!list_empty(&trace->evlist->core.entries)) {
5271		struct option o = {
5272			.value = &trace->evlist,
5273		};
5274		return parse_cgroups(&o, str, unset);
5275	}
5276	trace->cgroup = evlist__findnew_cgroup(trace->evlist, str);
5277
5278	return 0;
5279}
5280
5281static int trace__parse_summary_mode(const struct option *opt, const char *str,
5282				     int unset __maybe_unused)
5283{
5284	struct trace *trace = opt->value;
5285
5286	if (!strcmp(str, "thread")) {
5287		trace->summary_mode = SUMMARY__BY_THREAD;
5288	} else if (!strcmp(str, "total")) {
5289		trace->summary_mode = SUMMARY__BY_TOTAL;
5290	} else if (!strcmp(str, "cgroup")) {
5291		trace->summary_mode = SUMMARY__BY_CGROUP;
5292	} else {
5293		pr_err("Unknown summary mode: %s\n", str);
5294		return -1;
5295	}
5296
5297	return 0;
5298}
5299
5300static int trace__config(const char *var, const char *value, void *arg)
5301{
5302	struct trace *trace = arg;
5303	int err = 0;
5304
5305	if (!strcmp(var, "trace.add_events")) {
5306		trace->perfconfig_events = strdup(value);
5307		if (trace->perfconfig_events == NULL) {
5308			pr_err("Not enough memory for %s\n", "trace.add_events");
5309			return -1;
5310		}
5311	} else if (!strcmp(var, "trace.show_timestamp")) {
5312		trace->show_tstamp = perf_config_bool(var, value);
5313	} else if (!strcmp(var, "trace.show_duration")) {
5314		trace->show_duration = perf_config_bool(var, value);
5315	} else if (!strcmp(var, "trace.show_arg_names")) {
5316		trace->show_arg_names = perf_config_bool(var, value);
5317		if (!trace->show_arg_names)
5318			trace->show_zeros = true;
5319	} else if (!strcmp(var, "trace.show_zeros")) {
5320		bool new_show_zeros = perf_config_bool(var, value);
5321		if (!trace->show_arg_names && !new_show_zeros) {
5322			pr_warning("trace.show_zeros has to be set when trace.show_arg_names=no\n");
5323			goto out;
5324		}
5325		trace->show_zeros = new_show_zeros;
5326	} else if (!strcmp(var, "trace.show_prefix")) {
5327		trace->show_string_prefix = perf_config_bool(var, value);
5328	} else if (!strcmp(var, "trace.no_inherit")) {
5329		trace->opts.no_inherit = perf_config_bool(var, value);
5330	} else if (!strcmp(var, "trace.args_alignment")) {
5331		int args_alignment = 0;
5332		if (perf_config_int(&args_alignment, var, value) == 0)
5333			trace->args_alignment = args_alignment;
5334	} else if (!strcmp(var, "trace.tracepoint_beautifiers")) {
5335		if (strcasecmp(value, "libtraceevent") == 0)
5336			trace->libtraceevent_print = true;
5337		else if (strcasecmp(value, "libbeauty") == 0)
5338			trace->libtraceevent_print = false;
5339	}
5340out:
5341	return err;
5342}
5343
5344static void trace__exit(struct trace *trace)
5345{
5346	thread__zput(trace->current);
5347	strlist__delete(trace->ev_qualifier);
5348	zfree(&trace->ev_qualifier_ids.entries);
5349	if (trace->syscalls.table) {
5350		for (size_t i = 0; i < trace->syscalls.table_size; i++)
5351			syscall__delete(trace->syscalls.table[i]);
5352		zfree(&trace->syscalls.table);
5353	}
5354	zfree(&trace->perfconfig_events);
5355	evlist__delete(trace->evlist);
5356	trace->evlist = NULL;
5357	ordered_events__free(&trace->oe.data);
5358#ifdef HAVE_LIBBPF_SUPPORT
5359	btf__free(trace->btf);
5360	trace->btf = NULL;
5361#endif
5362}
5363
5364int cmd_trace(int argc, const char **argv)
5365{
5366	const char *trace_usage[] = {
5367		"perf trace [<options>] [<command>]",
5368		"perf trace [<options>] -- <command> [<options>]",
5369		"perf trace record [<options>] [<command>]",
5370		"perf trace record [<options>] -- <command> [<options>]",
5371		NULL
5372	};
5373	struct trace trace = {
5374		.opts = {
5375			.target = {
5376				.uses_mmap = true,
5377			},
5378			.user_freq     = UINT_MAX,
5379			.user_interval = ULLONG_MAX,
5380			.no_buffering  = true,
5381			.mmap_pages    = UINT_MAX,
5382		},
5383		.output = stderr,
5384		.show_comm = true,
5385		.show_tstamp = true,
5386		.show_duration = true,
5387		.show_arg_names = true,
5388		.args_alignment = 70,
5389		.trace_syscalls = false,
5390		.kernel_syscallchains = false,
5391		.max_stack = UINT_MAX,
5392		.max_events = ULONG_MAX,
5393	};
5394	const char *output_name = NULL;
5395	const struct option trace_options[] = {
5396	OPT_CALLBACK('e', "event", &trace, "event",
5397		     "event/syscall selector. use 'perf list' to list available events",
5398		     trace__parse_events_option),
5399	OPT_CALLBACK(0, "filter", &trace.evlist, "filter",
5400		     "event filter", parse_filter),
5401	OPT_BOOLEAN(0, "comm", &trace.show_comm,
5402		    "show the thread COMM next to its id"),
5403	OPT_BOOLEAN(0, "tool_stats", &trace.show_tool_stats, "show tool stats"),
5404	OPT_CALLBACK(0, "expr", &trace, "expr", "list of syscalls/events to trace",
5405		     trace__parse_events_option),
5406	OPT_STRING('o', "output", &output_name, "file", "output file name"),
5407	OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
5408	OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
5409		    "trace events on existing process id"),
5410	OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
5411		    "trace events on existing thread id"),
5412	OPT_CALLBACK(0, "filter-pids", &trace, "CSV list of pids",
5413		     "pids to filter (by the kernel)", trace__set_filter_pids_from_option),
5414	OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
5415		    "system-wide collection from all CPUs"),
5416	OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
5417		    "list of cpus to monitor"),
5418	OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
5419		    "child tasks do not inherit counters"),
5420	OPT_CALLBACK('m', "mmap-pages", &trace.opts.mmap_pages, "pages",
5421		     "number of mmap data pages", evlist__parse_mmap_pages),
5422	OPT_STRING('u', "uid", &trace.uid_str, "user", "user to profile"),
5423	OPT_CALLBACK(0, "duration", &trace, "float",
5424		     "show only events with duration > N.M ms",
5425		     trace__set_duration),
5426	OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
5427	OPT_INCR('v', "verbose", &verbose, "be more verbose"),
5428	OPT_BOOLEAN('T', "time", &trace.full_time,
5429		    "Show full timestamp, not time relative to first start"),
5430	OPT_BOOLEAN(0, "failure", &trace.failure_only,
5431		    "Show only syscalls that failed"),
5432	OPT_BOOLEAN('s', "summary", &trace.summary_only,
5433		    "Show only syscall summary with statistics"),
5434	OPT_BOOLEAN('S', "with-summary", &trace.summary,
5435		    "Show all syscalls and summary with statistics"),
5436	OPT_BOOLEAN(0, "errno-summary", &trace.errno_summary,
5437		    "Show errno stats per syscall, use with -s or -S"),
5438	OPT_CALLBACK(0, "summary-mode", &trace, "mode",
5439		     "How to show summary: select thread (default), total or cgroup",
5440		     trace__parse_summary_mode),
5441	OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",
5442		     "Trace pagefaults", parse_pagefaults, "maj"),
5443	OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),
5444	OPT_BOOLEAN('f', "force", &trace.force, "don't complain, do it"),
5445	OPT_CALLBACK(0, "call-graph", &trace.opts,
5446		     "record_mode[,record_size]", record_callchain_help,
5447		     &record_parse_callchain_opt),
5448	OPT_BOOLEAN(0, "libtraceevent_print", &trace.libtraceevent_print,
5449		    "Use libtraceevent to print the tracepoint arguments."),
5450	OPT_BOOLEAN(0, "kernel-syscall-graph", &trace.kernel_syscallchains,
5451		    "Show the kernel callchains on the syscall exit path"),
5452	OPT_ULONG(0, "max-events", &trace.max_events,
5453		"Set the maximum number of events to print, exit after that is reached. "),
5454	OPT_UINTEGER(0, "min-stack", &trace.min_stack,
5455		     "Set the minimum stack depth when parsing the callchain, "
5456		     "anything below the specified depth will be ignored."),
5457	OPT_UINTEGER(0, "max-stack", &trace.max_stack,
5458		     "Set the maximum stack depth when parsing the callchain, "
5459		     "anything beyond the specified depth will be ignored. "
5460		     "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
5461	OPT_BOOLEAN(0, "sort-events", &trace.sort_events,
5462			"Sort batch of events before processing, use if getting out of order events"),
5463	OPT_BOOLEAN(0, "print-sample", &trace.print_sample,
5464			"print the PERF_RECORD_SAMPLE PERF_SAMPLE_ info, for debugging"),
5465	OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
5466			"per thread proc mmap processing timeout in ms"),
5467	OPT_CALLBACK('G', "cgroup", &trace, "name", "monitor event in cgroup name only",
5468		     trace__parse_cgroups),
5469	OPT_INTEGER('D', "delay", &trace.opts.target.initial_delay,
5470		     "ms to wait before starting measurement after program "
5471		     "start"),
5472	OPT_BOOLEAN(0, "force-btf", &trace.force_btf, "Prefer btf_dump general pretty printer"
5473		       "to customized ones"),
5474	OPT_BOOLEAN(0, "bpf-summary", &trace.summary_bpf, "Summary syscall stats in BPF"),
5475	OPT_INTEGER(0, "max-summary", &trace.max_summary,
5476		     "Max number of entries in the summary."),
5477	OPTS_EVSWITCH(&trace.evswitch),
5478	OPT_END()
5479	};
5480	bool __maybe_unused max_stack_user_set = true;
5481	bool mmap_pages_user_set = true;
5482	struct evsel *evsel;
5483	const char * const trace_subcommands[] = { "record", NULL };
5484	int err = -1;
5485	char bf[BUFSIZ];
5486	struct sigaction sigchld_act;
5487
5488	signal(SIGSEGV, sighandler_dump_stack);
5489	signal(SIGFPE, sighandler_dump_stack);
5490	signal(SIGINT, sighandler_interrupt);
5491
5492	memset(&sigchld_act, 0, sizeof(sigchld_act));
5493	sigchld_act.sa_flags = SA_SIGINFO;
5494	sigchld_act.sa_sigaction = sighandler_chld;
5495	sigaction(SIGCHLD, &sigchld_act, NULL);
5496
5497	ordered_events__init(&trace.oe.data, ordered_events__deliver_event, &trace);
5498	ordered_events__set_copy_on_queue(&trace.oe.data, true);
5499
5500	trace.evlist = evlist__new();
5501
5502	if (trace.evlist == NULL) {
5503		pr_err("Not enough memory to run!\n");
5504		err = -ENOMEM;
5505		goto out;
5506	}
5507
5508	/*
5509	 * Parsing .perfconfig may entail creating a BPF event, that may need
5510	 * to create BPF maps, so bump RLIM_MEMLOCK as the default 64K setting
5511	 * is too small. This affects just this process, not touching the
5512	 * global setting. If it fails we'll get something in 'perf trace -v'
5513	 * to help diagnose the problem.
5514	 */
5515	rlimit__bump_memlock();
5516
5517	err = perf_config(trace__config, &trace);
5518	if (err)
5519		goto out;
5520
5521	argc = parse_options_subcommand(argc, argv, trace_options, trace_subcommands,
5522				 trace_usage, PARSE_OPT_STOP_AT_NON_OPTION);
5523
5524	/*
5525	 * Here we already passed thru trace__parse_events_option() and it has
5526	 * already figured out if -e syscall_name, if not but if --event
5527	 * foo:bar was used, the user is interested _just_ in those, say,
5528	 * tracepoint events, not in the strace-like syscall-name-based mode.
5529	 *
5530	 * This is important because we need to check if strace-like mode is
5531	 * needed to decided if we should filter out the eBPF
5532	 * __augmented_syscalls__ code, if it is in the mix, say, via
5533	 * .perfconfig trace.add_events, and filter those out.
5534	 */
5535	if (!trace.trace_syscalls && !trace.trace_pgfaults &&
5536	    trace.evlist->core.nr_entries == 0 /* Was --events used? */) {
5537		trace.trace_syscalls = true;
5538	}
5539	/*
5540	 * Now that we have --verbose figured out, lets see if we need to parse
5541	 * events from .perfconfig, so that if those events fail parsing, say some
5542	 * BPF program fails, then we'll be able to use --verbose to see what went
5543	 * wrong in more detail.
5544	 */
5545	if (trace.perfconfig_events != NULL) {
5546		struct parse_events_error parse_err;
5547
5548		parse_events_error__init(&parse_err);
5549		err = parse_events(trace.evlist, trace.perfconfig_events, &parse_err);
5550		if (err)
5551			parse_events_error__print(&parse_err, trace.perfconfig_events);
5552		parse_events_error__exit(&parse_err);
5553		if (err)
5554			goto out;
5555	}
5556
5557	if ((nr_cgroups || trace.cgroup) && !trace.opts.target.system_wide) {
5558		usage_with_options_msg(trace_usage, trace_options,
5559				       "cgroup monitoring only available in system-wide mode");
5560	}
5561
5562	if (!trace.trace_syscalls)
5563		goto skip_augmentation;
5564
5565	if ((argc >= 1) && (strcmp(argv[0], "record") == 0)) {
5566		pr_debug("Syscall augmentation fails with record, disabling augmentation");
5567		goto skip_augmentation;
5568	}
5569
5570	if (trace.summary_bpf) {
5571		if (!trace.opts.target.system_wide) {
5572			/* TODO: Add filters in the BPF to support other targets. */
5573			pr_err("Error: --bpf-summary only works for system-wide mode.\n");
5574			goto out;
5575		}
5576		if (trace.summary_only)
5577			goto skip_augmentation;
5578	}
5579
5580	err = augmented_syscalls__prepare();
5581	if (err < 0)
5582		goto skip_augmentation;
5583
5584	trace__add_syscall_newtp(&trace);
5585
5586	err = augmented_syscalls__create_bpf_output(trace.evlist);
5587	if (err == 0)
5588		trace.syscalls.events.bpf_output = evlist__last(trace.evlist);
5589
5590skip_augmentation:
5591	err = -1;
5592
5593	if (trace.trace_pgfaults) {
5594		trace.opts.sample_address = true;
5595		trace.opts.sample_time = true;
5596	}
5597
5598	if (trace.opts.mmap_pages == UINT_MAX)
5599		mmap_pages_user_set = false;
5600
5601	if (trace.max_stack == UINT_MAX) {
5602		trace.max_stack = input_name ? PERF_MAX_STACK_DEPTH : sysctl__max_stack();
5603		max_stack_user_set = false;
5604	}
5605
5606#ifdef HAVE_DWARF_UNWIND_SUPPORT
5607	if ((trace.min_stack || max_stack_user_set) && !callchain_param.enabled) {
5608		record_opts__parse_callchain(&trace.opts, &callchain_param, "dwarf", false);
5609	}
5610#endif
5611
5612	if (callchain_param.enabled) {
5613		if (!mmap_pages_user_set && geteuid() == 0)
5614			trace.opts.mmap_pages = perf_event_mlock_kb_in_pages() * 4;
5615
5616		symbol_conf.use_callchain = true;
5617	}
5618
5619	if (trace.evlist->core.nr_entries > 0) {
5620		bool use_btf = false;
5621
5622		evlist__set_default_evsel_handler(trace.evlist, trace__event_handler);
5623		if (evlist__set_syscall_tp_fields(trace.evlist, &use_btf)) {
5624			perror("failed to set syscalls:* tracepoint fields");
5625			goto out;
5626		}
5627
5628		if (use_btf)
5629			trace__load_vmlinux_btf(&trace);
5630	}
5631
5632	/*
5633	 * If we are augmenting syscalls, then combine what we put in the
5634	 * __augmented_syscalls__ BPF map with what is in the
5635	 * syscalls:sys_exit_FOO tracepoints, i.e. just like we do without BPF,
5636	 * combining raw_syscalls:sys_enter with raw_syscalls:sys_exit.
5637	 *
5638	 * We'll switch to look at two BPF maps, one for sys_enter and the
5639	 * other for sys_exit when we start augmenting the sys_exit paths with
5640	 * buffers that are being copied from kernel to userspace, think 'read'
5641	 * syscall.
5642	 */
5643	if (trace.syscalls.events.bpf_output) {
5644		evlist__for_each_entry(trace.evlist, evsel) {
5645			bool raw_syscalls_sys_exit = evsel__name_is(evsel, "raw_syscalls:sys_exit");
5646
5647			if (raw_syscalls_sys_exit) {
5648				trace.raw_augmented_syscalls = true;
5649				goto init_augmented_syscall_tp;
5650			}
5651
5652			if (trace.syscalls.events.bpf_output->priv == NULL &&
5653			    strstr(evsel__name(evsel), "syscalls:sys_enter")) {
5654				struct evsel *augmented = trace.syscalls.events.bpf_output;
5655				if (evsel__init_augmented_syscall_tp(augmented, evsel) ||
5656				    evsel__init_augmented_syscall_tp_args(augmented))
5657					goto out;
5658				/*
5659				 * Augmented is __augmented_syscalls__ BPF_OUTPUT event
5660				 * Above we made sure we can get from the payload the tp fields
5661				 * that we get from syscalls:sys_enter tracefs format file.
5662				 */
5663				augmented->handler = trace__sys_enter;
5664				/*
5665				 * Now we do the same for the *syscalls:sys_enter event so that
5666				 * if we handle it directly, i.e. if the BPF prog returns 0 so
5667				 * as not to filter it, then we'll handle it just like we would
5668				 * for the BPF_OUTPUT one:
5669				 */
5670				if (evsel__init_augmented_syscall_tp(evsel, evsel) ||
5671				    evsel__init_augmented_syscall_tp_args(evsel))
5672					goto out;
5673				evsel->handler = trace__sys_enter;
5674			}
5675
5676			if (strstarts(evsel__name(evsel), "syscalls:sys_exit_")) {
5677				struct syscall_tp *sc;
5678init_augmented_syscall_tp:
5679				if (evsel__init_augmented_syscall_tp(evsel, evsel))
5680					goto out;
5681				sc = __evsel__syscall_tp(evsel);
5682				/*
5683				 * For now with BPF raw_augmented we hook into
5684				 * raw_syscalls:sys_enter and there we get all
5685				 * 6 syscall args plus the tracepoint common
5686				 * fields and the syscall_nr (another long).
5687				 * So we check if that is the case and if so
5688				 * don't look after the sc->args_size but
5689				 * always after the full raw_syscalls:sys_enter
5690				 * payload, which is fixed.
5691				 *
5692				 * We'll revisit this later to pass
5693				 * s->args_size to the BPF augmenter (now
5694				 * tools/perf/examples/bpf/augmented_raw_syscalls.c,
5695				 * so that it copies only what we need for each
5696				 * syscall, like what happens when we use
5697				 * syscalls:sys_enter_NAME, so that we reduce
5698				 * the kernel/userspace traffic to just what is
5699				 * needed for each syscall.
5700				 */
5701				if (trace.raw_augmented_syscalls)
5702					trace.raw_augmented_syscalls_args_size = (6 + 1) * sizeof(long) + sc->id.offset;
5703				evsel__init_augmented_syscall_tp_ret(evsel);
5704				evsel->handler = trace__sys_exit;
5705			}
5706		}
5707	}
5708
5709	if ((argc >= 1) && (strcmp(argv[0], "record") == 0)) {
5710		err = trace__record(&trace, argc-1, &argv[1]);
5711		goto out;
5712	}
5713
5714	/* Using just --errno-summary will trigger --summary */
5715	if (trace.errno_summary && !trace.summary && !trace.summary_only)
5716		trace.summary_only = true;
5717
5718	/* summary_only implies summary option, but don't overwrite summary if set */
5719	if (trace.summary_only)
5720		trace.summary = trace.summary_only;
5721
5722	/* Keep exited threads, otherwise information might be lost for summary */
5723	if (trace.summary) {
5724		symbol_conf.keep_exited_threads = true;
5725		if (trace.summary_mode == SUMMARY__NONE)
5726			trace.summary_mode = SUMMARY__BY_THREAD;
5727
5728		if (!trace.summary_bpf && trace.summary_mode == SUMMARY__BY_CGROUP) {
5729			pr_err("Error: --summary-mode=cgroup only works with --bpf-summary\n");
5730			err = -EINVAL;
5731			goto out;
5732		}
5733	}
5734
5735	if (output_name != NULL) {
5736		err = trace__open_output(&trace, output_name);
5737		if (err < 0) {
5738			perror("failed to create output file");
5739			goto out;
5740		}
5741	}
5742
5743	err = evswitch__init(&trace.evswitch, trace.evlist, stderr);
5744	if (err)
5745		goto out_close;
5746
5747	err = target__validate(&trace.opts.target);
5748	if (err) {
5749		target__strerror(&trace.opts.target, err, bf, sizeof(bf));
5750		fprintf(trace.output, "%s", bf);
5751		goto out_close;
5752	}
5753
5754	if (trace.uid_str) {
5755		uid_t uid = parse_uid(trace.uid_str);
5756
5757		if (uid == UINT_MAX) {
5758			ui__error("Invalid User: %s", trace.uid_str);
5759			err = -EINVAL;
5760			goto out_close;
5761		}
5762		err = parse_uid_filter(trace.evlist, uid);
5763		if (err)
5764			goto out_close;
5765
5766		trace.opts.target.system_wide = true;
5767	}
5768
5769	if (!argc && target__none(&trace.opts.target))
5770		trace.opts.target.system_wide = true;
5771
5772	if (input_name)
5773		err = trace__replay(&trace);
5774	else
5775		err = trace__run(&trace, argc, argv);
5776
5777out_close:
5778	if (output_name != NULL)
5779		fclose(trace.output);
5780out:
5781	trace__exit(&trace);
5782	augmented_syscalls__cleanup();
5783	return err;
5784}