// SPDX-License-Identifier: GPL-2.0
#include "debug.h"
#include "evlist.h"
#include "evsel.h"
#include "evsel_config.h"
#include "parse-events.h"
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <api/fs/fs.h>
#include <subcmd/parse-options.h>
#include <perf/cpumap.h>
#include "cloexec.h"
#include "util/perf_api_probe.h"
#include "record.h"
#include "../perf-sys.h"
#include "topdown.h"
#include "map_symbol.h"
#include "mem-events.h"

/*
 * evsel__config_leader_sampling() uses special rules for leader sampling.
 * However, if the leader is an AUX area event, then assume the event to sample
 * is the next event.
 */
static struct evsel *evsel__read_sampler(struct evsel *evsel, struct evlist *evlist)
{
        struct evsel *leader = evsel__leader(evsel);

        if (evsel__is_aux_event(leader) || arch_topdown_sample_read(leader) ||
            is_mem_loads_aux_event(leader)) {
                evlist__for_each_entry(evlist, evsel) {
                        if (evsel__leader(evsel) == leader && evsel != evsel__leader(evsel))
                                return evsel;
                }
        }

        return leader;
}

static u64 evsel__config_term_mask(struct evsel *evsel)
{
        struct evsel_config_term *term;
        struct list_head *config_terms = &evsel->config_terms;
        u64 term_types = 0;

        list_for_each_entry(term, config_terms, list) {
                term_types |= 1 << term->type;
        }
        return term_types;
}

static void evsel__config_leader_sampling(struct evsel *evsel, struct evlist *evlist)
{
        struct perf_event_attr *attr = &evsel->core.attr;
        struct evsel *leader = evsel__leader(evsel);
        struct evsel *read_sampler;
        u64 term_types, freq_mask;

        if (!leader->sample_read)
                return;

        read_sampler = evsel__read_sampler(evsel, evlist);

        if (evsel == read_sampler)
                return;

        term_types = evsel__config_term_mask(evsel);
        /*
         * Disable sampling for all group members except those with explicit
         * config terms or the leader. In the case of an AUX area event, the 2nd
         * event in the group is the one that 'leads' the sampling.
         */
        freq_mask = (1 << EVSEL__CONFIG_TERM_FREQ) | (1 << EVSEL__CONFIG_TERM_PERIOD);
        if ((term_types & freq_mask) == 0) {
                attr->freq           = 0;
                attr->sample_freq    = 0;
                attr->sample_period  = 0;
        }
        if ((term_types & (1 << EVSEL__CONFIG_TERM_OVERWRITE)) == 0)
                attr->write_backward = 0;

        /*
         * We don't get a sample for slave events, we make them when delivering
         * the group leader sample. Set the slave event to follow the master
         * sample_type to ease up reporting.
         * An AUX area event also has sample_type requirements, so also include
         * the sample type bits from the leader's sample_type to cover that
         * case.
         */
        attr->sample_type = read_sampler->core.attr.sample_type |
                            leader->core.attr.sample_type;
}

void evlist__config(struct evlist *evlist, struct record_opts *opts, struct callchain_param *callchain)
{
        struct evsel *evsel;
        bool use_sample_identifier = false;
        bool use_comm_exec;
        bool sample_id = opts->sample_id;

        if (perf_cpu_map__cpu(evlist->core.user_requested_cpus, 0).cpu < 0)
                opts->no_inherit = true;

        use_comm_exec = perf_can_comm_exec();

        evlist__for_each_entry(evlist, evsel) {
                evsel__config(evsel, opts, callchain);
                if (evsel->tracking && use_comm_exec)
                        evsel->core.attr.comm_exec = 1;
        }

        /* Configure leader sampling here now that the sample type is known */
        evlist__for_each_entry(evlist, evsel)
                evsel__config_leader_sampling(evsel, evlist);

        if (opts->full_auxtrace || opts->sample_identifier) {
                /*
                 * Need to be able to synthesize and parse selected events with
                 * arbitrary sample types, which requires always being able to
                 * match the id.
                 */
                use_sample_identifier = perf_can_sample_identifier();
                sample_id = true;
        } else if (evlist->core.nr_entries > 1) {
                struct evsel *first = evlist__first(evlist);

                evlist__for_each_entry(evlist, evsel) {
                        if (evsel->core.attr.sample_type == first->core.attr.sample_type)
                                continue;
                        use_sample_identifier = perf_can_sample_identifier();
                        break;
                }
                sample_id = true;
        }

        if (sample_id) {
                evlist__for_each_entry(evlist, evsel)
                        evsel__set_sample_id(evsel, use_sample_identifier);
        }

        evlist__set_id_pos(evlist);
}

static int get_max_rate(unsigned int *rate)
{
        return sysctl__read_int("kernel/perf_event_max_sample_rate", (int *)rate);
}

static int record_opts__config_freq(struct record_opts *opts)
{
        bool user_freq = opts->user_freq != UINT_MAX;
        bool user_interval = opts->user_interval != ULLONG_MAX;
        unsigned int max_rate;

        if (user_interval && user_freq) {
                pr_err("cannot set frequency and period at the same time\n");
                return -1;
        }

        if (user_interval)
                opts->default_interval = opts->user_interval;
        if (user_freq)
                opts->freq = opts->user_freq;

        /*
         * User specified count overrides default frequency.
         */
        if (opts->default_interval)
                opts->freq = 0;
        else if (opts->freq) {
                opts->default_interval = opts->freq;
        } else {
                pr_err("frequency and count are zero, aborting\n");
                return -1;
        }

        if (get_max_rate(&max_rate))
                return 0;

        /*
         * User specified frequency is over current maximum.
         */
        if (user_freq && (max_rate < opts->freq)) {
                if (opts->strict_freq) {
                        pr_err("error: Maximum frequency rate (%'u Hz) exceeded.\n"
                               "       Please use -F freq option with a lower value or consider\n"
                               "       tweaking /proc/sys/kernel/perf_event_max_sample_rate.\n",
                               max_rate);
                        return -1;
                } else {
                        pr_warning("warning: Maximum frequency rate (%'u Hz) exceeded, throttling from %'u Hz to %'u Hz.\n"
                                   "         The limit can be raised via /proc/sys/kernel/perf_event_max_sample_rate.\n"
                                   "         The kernel will lower it when perf's interrupts take too long.\n"
                                   "         Use --strict-freq to disable this throttling, refusing to record.\n",
                                   max_rate, opts->freq, max_rate);

                        opts->freq = max_rate;
                }
        }

        /*
         * Default frequency is over current maximum.
         */
        if (max_rate < opts->freq) {
                pr_warning("Lowering default frequency rate from %u to %u.\n"
                           "Please consider tweaking "
                           "/proc/sys/kernel/perf_event_max_sample_rate.\n",
                           opts->freq, max_rate);
                opts->freq = max_rate;
        }

        return 0;
}

int record_opts__config(struct record_opts *opts)
{
        return record_opts__config_freq(opts);
}

bool evlist__can_select_event(struct evlist *evlist, const char *str)
{
        struct evlist *temp_evlist;
        struct evsel *evsel;
        int err, fd;
        struct perf_cpu cpu = { .cpu = 0 };
        bool ret = false;
        pid_t pid = -1;

        temp_evlist = evlist__new();
        if (!temp_evlist)
                return false;

        err = parse_event(temp_evlist, str);
        if (err)
                goto out_delete;

        evsel = evlist__last(temp_evlist);

        if (!evlist || perf_cpu_map__is_any_cpu_or_is_empty(evlist->core.user_requested_cpus)) {
                struct perf_cpu_map *cpus = perf_cpu_map__new_online_cpus();

                if (cpus)
                        cpu =  perf_cpu_map__cpu(cpus, 0);

                perf_cpu_map__put(cpus);
        } else {
                cpu = perf_cpu_map__cpu(evlist->core.user_requested_cpus, 0);
        }

        while (1) {
                fd = sys_perf_event_open(&evsel->core.attr, pid, cpu.cpu, -1,
                                         perf_event_open_cloexec_flag());
                if (fd < 0) {
                        if (pid == -1 && errno == EACCES) {
                                pid = 0;
                                continue;
                        }
                        goto out_delete;
                }
                break;
        }
        close(fd);
        ret = true;

out_delete:
        evlist__delete(temp_evlist);
        return ret;
}

int record__parse_freq(const struct option *opt, const char *str, int unset __maybe_unused)
{
        unsigned int freq;
        struct record_opts *opts = opt->value;

        if (!str)
                return -EINVAL;

        if (strcasecmp(str, "max") == 0) {
                if (get_max_rate(&freq)) {
                        pr_err("couldn't read /proc/sys/kernel/perf_event_max_sample_rate\n");
                        return -1;
                }
                pr_info("info: Using a maximum frequency rate of %'d Hz\n", freq);
        } else {
                freq = atoi(str);
        }

        opts->user_freq = freq;
        return 0;
}