]> git.ipfire.org Git - thirdparty/kernel/stable.git/commitdiff
perf tool: Move fill defaults into tool.c
authorIan Rogers <irogers@google.com>
Mon, 12 Aug 2024 20:46:56 +0000 (13:46 -0700)
committerArnaldo Carvalho de Melo <acme@redhat.com>
Mon, 12 Aug 2024 21:05:39 +0000 (18:05 -0300)
The aim here is to eventually make perf_tool__fill_defaults() an init
function so that the tools struct is more const.

Create a tool.c to go along with tool.h. Move perf_tool__fill_defaults()
out of session.c into tool.c along with the default stub values. Add
perf_tool__compressed_is_stub() for a test in
perf_session__process_user_event().

perf_session__process_compressed_event() is only used from being default
initialized so migrate into tool.c.

Signed-off-by: Ian Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Anshuman Khandual <anshuman.khandual@arm.com>
Cc: Athira Rajeev <atrajeev@linux.vnet.ibm.com>
Cc: Huacai Chen <chenhuacai@kernel.org>
Cc: Ilkka Koskinen <ilkka@os.amperecomputing.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Jonathan Cameron <jonathan.cameron@huawei.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Leo Yan <leo.yan@linux.dev>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mike Leach <mike.leach@linaro.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>
Cc: Nick Terrell <terrelln@fb.com>
Cc: Oliver Upton <oliver.upton@linux.dev>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Song Liu <song@kernel.org>
Cc: Sun Haiyong <sunhaiyong@loongson.cn>
Cc: Suzuki Poulouse <suzuki.poulose@arm.com>
Cc: Will Deacon <will@kernel.org>
Cc: Yanteng Si <siyanteng@loongson.cn>
Cc: Yicong Yang <yangyicong@hisilicon.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: https://lore.kernel.org/r/20240812204720.631678-5-irogers@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
tools/perf/util/Build
tools/perf/util/session.c
tools/perf/util/session.h
tools/perf/util/tool.c [new file with mode: 0644]
tools/perf/util/tool.h

index b24360c04aaea424820766ecf7957c1a8fff5fe4..f6f18b4228bbfe4d43bb545b550762c93f2ff876 100644 (file)
@@ -66,6 +66,7 @@ perf-util-y += map.o
 perf-util-y += maps.o
 perf-util-y += pstack.o
 perf-util-y += session.o
+perf-util-y += tool.o
 perf-util-y += sample-raw.o
 perf-util-y += s390-sample-raw.o
 perf-util-y += amd-sample-raw.o
index 41beebd0913c98adbfa8f9f50659c36cbc42290c..5c0e0341d39e1c2c8ce23749ebacc754844885a6 100644 (file)
 #include "annotate.h"
 #include <internal/lib.h>
 
-#ifdef HAVE_ZSTD_SUPPORT
-static int perf_session__process_compressed_event(struct perf_session *session,
-                                                 union perf_event *event, u64 file_offset,
-                                                 const char *file_path)
-{
-       void *src;
-       size_t decomp_size, src_size;
-       u64 decomp_last_rem = 0;
-       size_t mmap_len, decomp_len = session->header.env.comp_mmap_len;
-       struct decomp *decomp, *decomp_last = session->active_decomp->decomp_last;
-
-       if (decomp_last) {
-               decomp_last_rem = decomp_last->size - decomp_last->head;
-               decomp_len += decomp_last_rem;
-       }
-
-       mmap_len = sizeof(struct decomp) + decomp_len;
-       decomp = mmap(NULL, mmap_len, PROT_READ|PROT_WRITE,
-                     MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
-       if (decomp == MAP_FAILED) {
-               pr_err("Couldn't allocate memory for decompression\n");
-               return -1;
-       }
-
-       decomp->file_pos = file_offset;
-       decomp->file_path = file_path;
-       decomp->mmap_len = mmap_len;
-       decomp->head = 0;
-
-       if (decomp_last_rem) {
-               memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
-               decomp->size = decomp_last_rem;
-       }
-
-       src = (void *)event + sizeof(struct perf_record_compressed);
-       src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
-
-       decomp_size = zstd_decompress_stream(session->active_decomp->zstd_decomp, src, src_size,
-                               &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
-       if (!decomp_size) {
-               munmap(decomp, mmap_len);
-               pr_err("Couldn't decompress data\n");
-               return -1;
-       }
-
-       decomp->size += decomp_size;
-
-       if (session->active_decomp->decomp == NULL)
-               session->active_decomp->decomp = decomp;
-       else
-               session->active_decomp->decomp_last->next = decomp;
-
-       session->active_decomp->decomp_last = decomp;
-
-       pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
-
-       return 0;
-}
-#else /* !HAVE_ZSTD_SUPPORT */
-#define perf_session__process_compressed_event perf_session__process_compressed_event_stub
-#endif
-
 static int perf_session__deliver_event(struct perf_session *session,
                                       union perf_event *event,
                                       const struct perf_tool *tool,
@@ -321,251 +259,6 @@ void perf_session__delete(struct perf_session *session)
        free(session);
 }
 
-static int process_event_synth_tracing_data_stub(struct perf_session *session
-                                                __maybe_unused,
-                                                union perf_event *event
-                                                __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_event_synth_attr_stub(const struct perf_tool *tool __maybe_unused,
-                                        union perf_event *event __maybe_unused,
-                                        struct evlist **pevlist
-                                        __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_event_synth_event_update_stub(const struct perf_tool *tool __maybe_unused,
-                                                union perf_event *event __maybe_unused,
-                                                struct evlist **pevlist
-                                                __maybe_unused)
-{
-       if (dump_trace)
-               perf_event__fprintf_event_update(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_event_sample_stub(const struct perf_tool *tool __maybe_unused,
-                                    union perf_event *event __maybe_unused,
-                                    struct perf_sample *sample __maybe_unused,
-                                    struct evsel *evsel __maybe_unused,
-                                    struct machine *machine __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_event_stub(const struct perf_tool *tool __maybe_unused,
-                             union perf_event *event __maybe_unused,
-                             struct perf_sample *sample __maybe_unused,
-                             struct machine *machine __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_finished_round_stub(const struct perf_tool *tool __maybe_unused,
-                                      union perf_event *event __maybe_unused,
-                                      struct ordered_events *oe __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int skipn(int fd, off_t n)
-{
-       char buf[4096];
-       ssize_t ret;
-
-       while (n > 0) {
-               ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
-               if (ret <= 0)
-                       return ret;
-               n -= ret;
-       }
-
-       return 0;
-}
-
-static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
-                                      union perf_event *event)
-{
-       dump_printf(": unhandled!\n");
-       if (perf_data__is_pipe(session->data))
-               skipn(perf_data__fd(session->data), event->auxtrace.size);
-       return event->auxtrace.size;
-}
-
-static int process_event_op2_stub(struct perf_session *session __maybe_unused,
-                                 union perf_event *event __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-
-static
-int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
-                                 union perf_event *event __maybe_unused)
-{
-       if (dump_trace)
-               perf_event__fprintf_thread_map(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static
-int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
-                              union perf_event *event __maybe_unused)
-{
-       if (dump_trace)
-               perf_event__fprintf_cpu_map(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static
-int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
-                                  union perf_event *event __maybe_unused)
-{
-       if (dump_trace)
-               perf_event__fprintf_stat_config(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
-                            union perf_event *event)
-{
-       if (dump_trace)
-               perf_event__fprintf_stat(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
-                                  union perf_event *event)
-{
-       if (dump_trace)
-               perf_event__fprintf_stat_round(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int process_event_time_conv_stub(struct perf_session *perf_session __maybe_unused,
-                                       union perf_event *event)
-{
-       if (dump_trace)
-               perf_event__fprintf_time_conv(event, stdout);
-
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-static int perf_session__process_compressed_event_stub(struct perf_session *session __maybe_unused,
-                                                      union perf_event *event __maybe_unused,
-                                                      u64 file_offset __maybe_unused,
-                                                      const char *file_path __maybe_unused)
-{
-       dump_printf(": unhandled!\n");
-       return 0;
-}
-
-void perf_tool__fill_defaults(struct perf_tool *tool)
-{
-       if (tool->sample == NULL)
-               tool->sample = process_event_sample_stub;
-       if (tool->mmap == NULL)
-               tool->mmap = process_event_stub;
-       if (tool->mmap2 == NULL)
-               tool->mmap2 = process_event_stub;
-       if (tool->comm == NULL)
-               tool->comm = process_event_stub;
-       if (tool->namespaces == NULL)
-               tool->namespaces = process_event_stub;
-       if (tool->cgroup == NULL)
-               tool->cgroup = process_event_stub;
-       if (tool->fork == NULL)
-               tool->fork = process_event_stub;
-       if (tool->exit == NULL)
-               tool->exit = process_event_stub;
-       if (tool->lost == NULL)
-               tool->lost = perf_event__process_lost;
-       if (tool->lost_samples == NULL)
-               tool->lost_samples = perf_event__process_lost_samples;
-       if (tool->aux == NULL)
-               tool->aux = perf_event__process_aux;
-       if (tool->itrace_start == NULL)
-               tool->itrace_start = perf_event__process_itrace_start;
-       if (tool->context_switch == NULL)
-               tool->context_switch = perf_event__process_switch;
-       if (tool->ksymbol == NULL)
-               tool->ksymbol = perf_event__process_ksymbol;
-       if (tool->bpf == NULL)
-               tool->bpf = perf_event__process_bpf;
-       if (tool->text_poke == NULL)
-               tool->text_poke = perf_event__process_text_poke;
-       if (tool->aux_output_hw_id == NULL)
-               tool->aux_output_hw_id = perf_event__process_aux_output_hw_id;
-       if (tool->read == NULL)
-               tool->read = process_event_sample_stub;
-       if (tool->throttle == NULL)
-               tool->throttle = process_event_stub;
-       if (tool->unthrottle == NULL)
-               tool->unthrottle = process_event_stub;
-       if (tool->attr == NULL)
-               tool->attr = process_event_synth_attr_stub;
-       if (tool->event_update == NULL)
-               tool->event_update = process_event_synth_event_update_stub;
-       if (tool->tracing_data == NULL)
-               tool->tracing_data = process_event_synth_tracing_data_stub;
-       if (tool->build_id == NULL)
-               tool->build_id = process_event_op2_stub;
-       if (tool->finished_round == NULL) {
-               if (tool->ordered_events)
-                       tool->finished_round = perf_event__process_finished_round;
-               else
-                       tool->finished_round = process_finished_round_stub;
-       }
-       if (tool->id_index == NULL)
-               tool->id_index = process_event_op2_stub;
-       if (tool->auxtrace_info == NULL)
-               tool->auxtrace_info = process_event_op2_stub;
-       if (tool->auxtrace == NULL)
-               tool->auxtrace = process_event_auxtrace_stub;
-       if (tool->auxtrace_error == NULL)
-               tool->auxtrace_error = process_event_op2_stub;
-       if (tool->thread_map == NULL)
-               tool->thread_map = process_event_thread_map_stub;
-       if (tool->cpu_map == NULL)
-               tool->cpu_map = process_event_cpu_map_stub;
-       if (tool->stat_config == NULL)
-               tool->stat_config = process_event_stat_config_stub;
-       if (tool->stat == NULL)
-               tool->stat = process_stat_stub;
-       if (tool->stat_round == NULL)
-               tool->stat_round = process_stat_round_stub;
-       if (tool->time_conv == NULL)
-               tool->time_conv = process_event_time_conv_stub;
-       if (tool->feature == NULL)
-               tool->feature = process_event_op2_stub;
-       if (tool->compressed == NULL)
-               tool->compressed = perf_session__process_compressed_event;
-       if (tool->finished_init == NULL)
-               tool->finished_init = process_event_op2_stub;
-}
-
 static void swap_sample_id_all(union perf_event *event, void *data)
 {
        void *end = (void *) event + event->header.size;
@@ -1677,8 +1370,7 @@ static s64 perf_session__process_user_event(struct perf_session *session,
        int fd = perf_data__fd(session->data);
        int err;
 
-       if (event->header.type != PERF_RECORD_COMPRESSED ||
-           tool->compressed == perf_session__process_compressed_event_stub)
+       if (event->header.type != PERF_RECORD_COMPRESSED || perf_tool__compressed_is_stub(tool))
                dump_event(session->evlist, event, file_offset, &sample, file_path);
 
        /* These events are processed right away */
index 6886cc85600f21863332d08128e983c3e2a9ddfa..7f69baeae7fb65ce7b3a10d866b39aec39804ca5 100644 (file)
@@ -92,8 +92,6 @@ int perf_session__process_events(struct perf_session *session);
 int perf_session__queue_event(struct perf_session *s, union perf_event *event,
                              u64 timestamp, u64 file_offset, const char *file_path);
 
-void perf_tool__fill_defaults(struct perf_tool *tool);
-
 int perf_session__resolve_callchain(struct perf_session *session,
                                    struct evsel *evsel,
                                    struct thread *thread,
diff --git a/tools/perf/util/tool.c b/tools/perf/util/tool.c
new file mode 100644 (file)
index 0000000..17219ec
--- /dev/null
@@ -0,0 +1,325 @@
+// SPDX-License-Identifier: GPL-2.0
+#include "data.h"
+#include "debug.h"
+#include "header.h"
+#include "session.h"
+#include "stat.h"
+#include "tool.h"
+#include "tsc.h"
+#include <sys/mman.h>
+#include <unistd.h>
+
+#ifdef HAVE_ZSTD_SUPPORT
+static int perf_session__process_compressed_event(struct perf_session *session,
+                                                 union perf_event *event, u64 file_offset,
+                                                 const char *file_path)
+{
+       void *src;
+       size_t decomp_size, src_size;
+       u64 decomp_last_rem = 0;
+       size_t mmap_len, decomp_len = session->header.env.comp_mmap_len;
+       struct decomp *decomp, *decomp_last = session->active_decomp->decomp_last;
+
+       if (decomp_last) {
+               decomp_last_rem = decomp_last->size - decomp_last->head;
+               decomp_len += decomp_last_rem;
+       }
+
+       mmap_len = sizeof(struct decomp) + decomp_len;
+       decomp = mmap(NULL, mmap_len, PROT_READ|PROT_WRITE,
+                     MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+       if (decomp == MAP_FAILED) {
+               pr_err("Couldn't allocate memory for decompression\n");
+               return -1;
+       }
+
+       decomp->file_pos = file_offset;
+       decomp->file_path = file_path;
+       decomp->mmap_len = mmap_len;
+       decomp->head = 0;
+
+       if (decomp_last_rem) {
+               memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
+               decomp->size = decomp_last_rem;
+       }
+
+       src = (void *)event + sizeof(struct perf_record_compressed);
+       src_size = event->pack.header.size - sizeof(struct perf_record_compressed);
+
+       decomp_size = zstd_decompress_stream(session->active_decomp->zstd_decomp, src, src_size,
+                               &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
+       if (!decomp_size) {
+               munmap(decomp, mmap_len);
+               pr_err("Couldn't decompress data\n");
+               return -1;
+       }
+
+       decomp->size += decomp_size;
+
+       if (session->active_decomp->decomp == NULL)
+               session->active_decomp->decomp = decomp;
+       else
+               session->active_decomp->decomp_last->next = decomp;
+
+       session->active_decomp->decomp_last = decomp;
+
+       pr_debug("decomp (B): %zd to %zd\n", src_size, decomp_size);
+
+       return 0;
+}
+#endif
+
+static int process_event_synth_tracing_data_stub(struct perf_session *session
+                                                __maybe_unused,
+                                                union perf_event *event
+                                                __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_event_synth_attr_stub(const struct perf_tool *tool __maybe_unused,
+                                        union perf_event *event __maybe_unused,
+                                        struct evlist **pevlist
+                                        __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_event_synth_event_update_stub(const struct perf_tool *tool __maybe_unused,
+                                                union perf_event *event __maybe_unused,
+                                                struct evlist **pevlist
+                                                __maybe_unused)
+{
+       if (dump_trace)
+               perf_event__fprintf_event_update(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_event_sample_stub(const struct perf_tool *tool __maybe_unused,
+                                    union perf_event *event __maybe_unused,
+                                    struct perf_sample *sample __maybe_unused,
+                                    struct evsel *evsel __maybe_unused,
+                                    struct machine *machine __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_event_stub(const struct perf_tool *tool __maybe_unused,
+                             union perf_event *event __maybe_unused,
+                             struct perf_sample *sample __maybe_unused,
+                             struct machine *machine __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_finished_round_stub(const struct perf_tool *tool __maybe_unused,
+                                      union perf_event *event __maybe_unused,
+                                      struct ordered_events *oe __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int skipn(int fd, off_t n)
+{
+       char buf[4096];
+       ssize_t ret;
+
+       while (n > 0) {
+               ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
+               if (ret <= 0)
+                       return ret;
+               n -= ret;
+       }
+
+       return 0;
+}
+
+static s64 process_event_auxtrace_stub(struct perf_session *session __maybe_unused,
+                                      union perf_event *event)
+{
+       dump_printf(": unhandled!\n");
+       if (perf_data__is_pipe(session->data))
+               skipn(perf_data__fd(session->data), event->auxtrace.size);
+       return event->auxtrace.size;
+}
+
+static int process_event_op2_stub(struct perf_session *session __maybe_unused,
+                                 union perf_event *event __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+
+static
+int process_event_thread_map_stub(struct perf_session *session __maybe_unused,
+                                 union perf_event *event __maybe_unused)
+{
+       if (dump_trace)
+               perf_event__fprintf_thread_map(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static
+int process_event_cpu_map_stub(struct perf_session *session __maybe_unused,
+                              union perf_event *event __maybe_unused)
+{
+       if (dump_trace)
+               perf_event__fprintf_cpu_map(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static
+int process_event_stat_config_stub(struct perf_session *session __maybe_unused,
+                                  union perf_event *event __maybe_unused)
+{
+       if (dump_trace)
+               perf_event__fprintf_stat_config(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_stat_stub(struct perf_session *perf_session __maybe_unused,
+                            union perf_event *event)
+{
+       if (dump_trace)
+               perf_event__fprintf_stat(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_stat_round_stub(struct perf_session *perf_session __maybe_unused,
+                                  union perf_event *event)
+{
+       if (dump_trace)
+               perf_event__fprintf_stat_round(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int process_event_time_conv_stub(struct perf_session *perf_session __maybe_unused,
+                                       union perf_event *event)
+{
+       if (dump_trace)
+               perf_event__fprintf_time_conv(event, stdout);
+
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+static int perf_session__process_compressed_event_stub(struct perf_session *session __maybe_unused,
+                                                      union perf_event *event __maybe_unused,
+                                                      u64 file_offset __maybe_unused,
+                                                      const char *file_path __maybe_unused)
+{
+       dump_printf(": unhandled!\n");
+       return 0;
+}
+
+void perf_tool__fill_defaults(struct perf_tool *tool)
+{
+       if (tool->sample == NULL)
+               tool->sample = process_event_sample_stub;
+       if (tool->mmap == NULL)
+               tool->mmap = process_event_stub;
+       if (tool->mmap2 == NULL)
+               tool->mmap2 = process_event_stub;
+       if (tool->comm == NULL)
+               tool->comm = process_event_stub;
+       if (tool->namespaces == NULL)
+               tool->namespaces = process_event_stub;
+       if (tool->cgroup == NULL)
+               tool->cgroup = process_event_stub;
+       if (tool->fork == NULL)
+               tool->fork = process_event_stub;
+       if (tool->exit == NULL)
+               tool->exit = process_event_stub;
+       if (tool->lost == NULL)
+               tool->lost = perf_event__process_lost;
+       if (tool->lost_samples == NULL)
+               tool->lost_samples = perf_event__process_lost_samples;
+       if (tool->aux == NULL)
+               tool->aux = perf_event__process_aux;
+       if (tool->itrace_start == NULL)
+               tool->itrace_start = perf_event__process_itrace_start;
+       if (tool->context_switch == NULL)
+               tool->context_switch = perf_event__process_switch;
+       if (tool->ksymbol == NULL)
+               tool->ksymbol = perf_event__process_ksymbol;
+       if (tool->bpf == NULL)
+               tool->bpf = perf_event__process_bpf;
+       if (tool->text_poke == NULL)
+               tool->text_poke = perf_event__process_text_poke;
+       if (tool->aux_output_hw_id == NULL)
+               tool->aux_output_hw_id = perf_event__process_aux_output_hw_id;
+       if (tool->read == NULL)
+               tool->read = process_event_sample_stub;
+       if (tool->throttle == NULL)
+               tool->throttle = process_event_stub;
+       if (tool->unthrottle == NULL)
+               tool->unthrottle = process_event_stub;
+       if (tool->attr == NULL)
+               tool->attr = process_event_synth_attr_stub;
+       if (tool->event_update == NULL)
+               tool->event_update = process_event_synth_event_update_stub;
+       if (tool->tracing_data == NULL)
+               tool->tracing_data = process_event_synth_tracing_data_stub;
+       if (tool->build_id == NULL)
+               tool->build_id = process_event_op2_stub;
+       if (tool->finished_round == NULL) {
+               if (tool->ordered_events)
+                       tool->finished_round = perf_event__process_finished_round;
+               else
+                       tool->finished_round = process_finished_round_stub;
+       }
+       if (tool->id_index == NULL)
+               tool->id_index = process_event_op2_stub;
+       if (tool->auxtrace_info == NULL)
+               tool->auxtrace_info = process_event_op2_stub;
+       if (tool->auxtrace == NULL)
+               tool->auxtrace = process_event_auxtrace_stub;
+       if (tool->auxtrace_error == NULL)
+               tool->auxtrace_error = process_event_op2_stub;
+       if (tool->thread_map == NULL)
+               tool->thread_map = process_event_thread_map_stub;
+       if (tool->cpu_map == NULL)
+               tool->cpu_map = process_event_cpu_map_stub;
+       if (tool->stat_config == NULL)
+               tool->stat_config = process_event_stat_config_stub;
+       if (tool->stat == NULL)
+               tool->stat = process_stat_stub;
+       if (tool->stat_round == NULL)
+               tool->stat_round = process_stat_round_stub;
+       if (tool->time_conv == NULL)
+               tool->time_conv = process_event_time_conv_stub;
+       if (tool->feature == NULL)
+               tool->feature = process_event_op2_stub;
+       if (tool->compressed == NULL) {
+#ifdef HAVE_ZSTD_SUPPORT
+               tool->compressed = perf_session__process_compressed_event;
+#else
+               tool->compressed = perf_session__process_compressed_event_stub;
+#endif
+       }
+       if (tool->finished_init == NULL)
+               tool->finished_init = process_event_op2_stub;
+}
+
+bool perf_tool__compressed_is_stub(const struct perf_tool *tool)
+{
+       return tool->compressed == perf_session__process_compressed_event_stub;
+}
index 2b12c674768f1b18ae21776c26c729c38b7a1a48..b917b1fa6204db6d267d6c331d2e3c7dae510d98 100644 (file)
@@ -89,4 +89,8 @@ struct perf_tool {
        enum show_feature_header show_feat_hdr;
 };
 
+void perf_tool__fill_defaults(struct perf_tool *tool);
+
+bool perf_tool__compressed_is_stub(const struct perf_tool *tool);
+
 #endif /* __PERF_TOOL_H */