#include "util/synthetic-events.h"

#include "util/evlist.h"

#include "util/evswitch.h"

#include "util/mmap.h"

#include <subcmd/pager.h>

#include <subcmd/exec-cmd.h>

#include "print_binary.h"

#include "string2.h"

#include "syscalltbl.h"

#include "../perf.h"

#include "trace_augment.h"

#include <errno.h>

#include <inttypes.h>

#include <linux/ctype.h>

#include <perf/mmap.h>

#ifdef HAVE_LIBTRACEEVENT

#include <event-parse.h>

bool hexret;

};

struct trace {

struct perf_tool tool;

struct {

struct {

struct evsel *sys_enter,

*sys_exit,

pid_t *entries;

struct bpf_map *map;

} filter_pids;

double duration_filter;

double runtime_ms;

struct {

u64 vfs_getname,

proc_getname;

} stats;

unsigned int max_stack;

unsigned int min_stack;

int raw_augmented_syscalls_args_size;

bool raw_augmented_syscalls;

bool fd_path_disabled;

return __syscall_fmt__find_by_alias(syscall_fmts, nmemb, alias);

}

*/

struct syscall {

struct tep_event *tp_format;

int nr_args;

int args_size;

struct {

struct bpf_program *sys_enter,

*sys_exit;

} bpf_prog;

bool is_exit;

bool is_open;

bool nonexistent;

bool use_btf;

struct tep_format_field *args;

struct file *table;

} files;

};

{

struct thread_trace *ttrace = zalloc(sizeof(struct thread_trace));

if (ttrace) {

ttrace->files.max = -1;

}

return ttrace;

if (!ttrace)

return;

ttrace->syscall_stats = NULL;

thread_trace__free_files(ttrace);

zfree(&ttrace->entry_str);

free(ttrace);

}

{

struct thread_trace *ttrace;

goto fail;

if (thread__priv(thread) == NULL)

if (thread__priv(thread) == NULL)

goto fail;

return ttrace;

fail:

"WARNING: not enough memory, dropping samples!\n");

return NULL;

}

return 0;

}

{

char tp_name[128];

int err;

if (sc->nonexistent)

return -EEXIST;

if (name == NULL) {

sc->nonexistent = true;

return -EEXIST;

*/

if (IS_ERR(sc->tp_format)) {

sc->nonexistent = true;

}

return -ENOMEM;

sc->args = sc->tp_format->format.fields;

strlist__for_each_entry(pos, trace->ev_qualifier) {

const char *sc = pos->s;

if (id < 0) {

if (id >= 0)

goto matches;

continue;

while (1) {

if (id < 0)

break;

if (nr_allocated == nr_used) {

return printed;

}

typedef int (*tracepoint_handler)(struct trace *trace, struct evsel *evsel,

union perf_event *event,

struct perf_sample *sample);

{

int err = 0;

if (id < 0) {

err = -EINVAL;

char sbuf[STRERR_BUFSIZE];

fputs(" information\n", trace->output);

}

}

struct syscall_stats {

};

static void thread__update_stats(struct thread *thread, struct thread_trace *ttrace,

{

u64 duration = 0;

stats = zalloc(sizeof(*stats));

if (stats == NULL)

return;

init_stats(&stats->stats);

}

if (ttrace->entry_time && sample->time > ttrace->entry_time)

if (err < 0) {

++stats->nr_failures;

return;

err = -err;

return NULL;

}

static int trace__sys_enter(struct trace *trace, struct evsel *evsel,

union perf_event *event __maybe_unused,

struct perf_sample *sample)

int printed = 0;

struct thread *thread;

int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;

void *augmented_args = NULL;

struct thread_trace *ttrace;

thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);

if (ttrace == NULL)

goto out_put;

struct thread_trace *ttrace;

struct thread *thread;

int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1;

char msg[1024];

void *args, *augmented_args = NULL;

size_t printed = 0;

thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);

/*

* We need to get ttrace just to make sure it is there when syscall__scnprintf_args()

* and the rest of the beautifiers accessing it via struct syscall_arg touches it.

bool duration_calculated = false;

struct thread *thread;

int id = perf_evsel__sc_tp_uint(evsel, id, sample), err = -1, callchain_ret = 0, printed = 0;

struct thread_trace *ttrace;

thread = machine__findnew_thread(trace->host, sample->pid, sample->tid);

if (ttrace == NULL)

goto out_put;

ret = perf_evsel__sc_tp_uint(evsel, ret, sample);

if (trace->summary)

if (!trace->fd_path_disabled && sc->is_open && ret >= 0 && ttrace->filename.pending_open) {

trace__set_fd_pathname(thread, ret, ttrace->filename.name);

struct thread *thread = machine__findnew_thread(trace->host,

sample->pid,

sample->tid);

if (ttrace == NULL)

goto out_dump;

printed += syscall_arg_fmt__scnprintf_val(arg, bf + printed, size - printed, &syscall_arg, val);

}

}

static int trace__event_handler(struct trace *trace, struct evsel *evsel,

if (evsel == trace->syscalls.events.bpf_output) {

int id = perf_evsel__sc_tp_uint(evsel, id, sample);

if (sc) {

fprintf(trace->output, "%s(", sc->name);

}

}

if (ttrace == NULL)

goto out_put;

ttrace->pfmaj++;

ttrace->pfmin++;

if (trace->summary_only)

goto out;

}

static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp);

static bool evlist__add_vfs_getname(struct evlist *evlist)

{

return trace->skel->progs.syscall_unaugmented;

}

{

if (sc == NULL)

return;

sc->bpf_prog.sys_exit = trace__find_syscall_bpf_prog(trace, sc, sc->fmt ? sc->fmt->bpf_prog_name.sys_exit : NULL, "exit");

}

{

return sc ? bpf_program__fd(sc->bpf_prog.sys_enter) : bpf_program__fd(trace->skel->progs.syscall_unaugmented);

}

{

return sc ? bpf_program__fd(sc->bpf_prog.sys_exit) : bpf_program__fd(trace->skel->progs.syscall_unaugmented);

}

{

struct tep_format_field *field;

const struct btf_type *bt;

char *struct_offset, *tmp, name[32];

bool can_augment = false;

return -1;

}

{

struct tep_format_field *field, *candidate_field;

/*

return NULL;

try_to_find_pair:

struct bpf_program *pair_prog;

bool is_candidate = false;

pair->bpf_prog.sys_enter == trace->skel->progs.syscall_unaugmented)

continue;

goto next_candidate;

}

return pair_prog;

next_candidate:

continue;

return NULL;

}

{

int map_enter_fd = bpf_map__fd(trace->skel->maps.syscalls_sys_enter);

int map_exit_fd = bpf_map__fd(trace->skel->maps.syscalls_sys_exit);

int err = 0;

unsigned int beauty_array[6];

if (!trace__syscall_enabled(trace, key))

continue;

// It'll get at least the "!raw_syscalls:unaugmented"

err = bpf_map_update_elem(map_enter_fd, &key, &prog_fd, BPF_ANY);

if (err)

break;

err = bpf_map_update_elem(map_exit_fd, &key, &prog_fd, BPF_ANY);

if (err)

break;

/* use beauty_map to tell BPF how many bytes to collect, set beauty_map's value here */

memset(beauty_array, 0, sizeof(beauty_array));

if (err)

continue;

err = bpf_map_update_elem(beauty_map_fd, &key, beauty_array, BPF_ANY);

* first and second arg (this one on the raw_syscalls:sys_exit prog

* array tail call, then that one will be used.

*/

struct bpf_program *pair_prog;

int prog_fd;

{

struct evlist *evlist = trace->evlist;

struct perf_sample sample;

if (err)

fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);

else

trace__handle_event(trace, event, &sample);

return 0;

}

goto out_delete_evlist;

}

evlist__config(evlist, &trace->opts, &callchain_param);

if (forks) {

* CPU the bpf-output event's file descriptor.

*/

perf_cpu_map__for_each_cpu(cpu, i, trace->syscalls.events.bpf_output->core.cpus) {

bpf_map__update_elem(trace->skel->maps.__augmented_syscalls__,

xyarray__entry(trace->syscalls.events.bpf_output->core.fd,

sizeof(__u32), BPF_ANY);

}

}

goto out_error_mem;

#ifdef HAVE_BPF_SKEL

#endif

if (trace->ev_qualifier_ids.nr > 0) {

* So just disable this beautifier (SCA_FD, SCA_FDAT) when 'close' is

* not in use.

*/

err = trace__expand_filters(trace, &evsel);

if (err)

ordered_events__flush(&trace->oe.data, OE_FLUSH__FINAL);

if (!err) {

if (trace->show_tool_stats) {

fprintf(trace->output, "Stats:\n "

}

out_delete_evlist:

trace__symbols__exit(trace);

evlist__free_syscall_tp_fields(evlist);

evlist__delete(evlist);

struct evsel *evsel;

int err = -1;

trace->tool.sample = trace__process_sample;

trace->tool.mmap = perf_event__process_mmap;

trace->tool.mmap2 = perf_event__process_mmap2;

evsel->handler = trace__pgfault;

}

setup_pager();

err = perf_session__process_events(session);

trace__fprintf_thread_summary(trace, trace->output);

out:

perf_session__delete(session);

return err;

}

{

size_t printed;

return printed;

}

struct syscall_stats *stats;

double msecs;

int syscall;

{

}

{

size_t printed = 0;

struct syscall *sc;

return 0;

printed += fprintf(fp, "\n");

printed += fprintf(fp, " (msec) (msec) (msec) (msec) (%%)\n");

printed += fprintf(fp, " --------------- -------- ------ -------- --------- --------- --------- ------\n");

if (stats) {

double min = (double)(stats->stats.min) / NSEC_PER_MSEC;

double max = (double)(stats->stats.max) / NSEC_PER_MSEC;

pct = avg ? 100.0 * stddev_stats(&stats->stats) / avg : 0.0;

avg /= NSEC_PER_MSEC;

printed += fprintf(fp, " %-15s", sc->name);

printed += fprintf(fp, " %8" PRIu64 " %6" PRIu64 " %9.3f %9.3f %9.3f",

printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);

if (trace->errno_summary && stats->nr_failures) {

}

}

printed += fprintf(fp, "\n\n");

return printed;

}

static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)

{

size_t printed = 0;

struct thread_trace *ttrace = thread__priv(thread);

double ratio;

if (ttrace == NULL)

else if (fputc('\n', fp) != EOF)

++printed;

return printed;

}

static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)

{

LIST_HEAD(threads);

if (machine__thread_list(trace->host, &threads) == 0) {

return printed;

}

static int trace__set_duration(const struct option *opt, const char *str,

int unset __maybe_unused)

{

*sep = '\0';

list = 0;

list = 1;

goto do_concat;

}

return 0;

}

static int trace__config(const char *var, const char *value, void *arg)

{

struct trace *trace = arg;

static void trace__exit(struct trace *trace)

{

strlist__delete(trace->ev_qualifier);

zfree(&trace->ev_qualifier_ids.entries);

if (trace->syscalls.table) {

zfree(&trace->syscalls.table);

}

zfree(&trace->perfconfig_events);

}

#ifdef HAVE_BPF_SKEL

"Show all syscalls and summary with statistics"),

OPT_BOOLEAN(0, "errno-summary", &trace.errno_summary,

"Show errno stats per syscall, use with -s or -S"),

OPT_CALLBACK_DEFAULT('F', "pf", &trace.trace_pgfaults, "all|maj|min",

"Trace pagefaults", parse_pagefaults, "maj"),

OPT_BOOLEAN(0, "syscalls", &trace.trace_syscalls, "Trace syscalls"),

sigaction(SIGCHLD, &sigchld_act, NULL);

trace.evlist = evlist__new();

pr_err("Not enough memory to run!\n");

err = -ENOMEM;

goto out;

}

}

/* Using just --errno-summary will trigger --summary */

if (trace.errno_summary && !trace.summary && !trace.summary_only)

trace.summary = trace.summary_only;

/* Keep exited threads, otherwise information might be lost for summary */

symbol_conf.keep_exited_threads = true;

if (output_name != NULL) {

err = trace__open_output(&trace, output_name);