// SPDX-License-Identifier: GPL-2.0
/*
 * Description: PMUs specific to running nested KVM-HV guests
 * on Book3S processors (specifically POWER9 and later).
 */

#define pr_fmt(fmt)  "kvmppc-pmu: " fmt

#include "asm-generic/local64.h"
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/ratelimit.h>
#include <linux/kvm_host.h>
#include <linux/gfp_types.h>
#include <linux/pgtable.h>
#include <linux/perf_event.h>
#include <linux/spinlock_types.h>
#include <linux/spinlock.h>

#include <asm/types.h>
#include <asm/kvm_ppc.h>
#include <asm/kvm_book3s.h>
#include <asm/mmu.h>
#include <asm/pgalloc.h>
#include <asm/pte-walk.h>
#include <asm/reg.h>
#include <asm/plpar_wrappers.h>
#include <asm/firmware.h>

#include "asm/guest-state-buffer.h"

enum kvmppc_pmu_eventid {
        KVMPPC_EVENT_HOST_HEAP,
        KVMPPC_EVENT_HOST_HEAP_MAX,
        KVMPPC_EVENT_HOST_PGTABLE,
        KVMPPC_EVENT_HOST_PGTABLE_MAX,
        KVMPPC_EVENT_HOST_PGTABLE_RECLAIM,
        KVMPPC_EVENT_MAX,
};

#define KVMPPC_PMU_EVENT_ATTR(_name, _id) \
        PMU_EVENT_ATTR_ID(_name, kvmppc_events_sysfs_show, _id)

static ssize_t kvmppc_events_sysfs_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *page)
{
        struct perf_pmu_events_attr *pmu_attr;

        pmu_attr = container_of(attr, struct perf_pmu_events_attr, attr);
        return sprintf(page, "event=0x%02llx\n", pmu_attr->id);
}

/* Holds the hostwide stats */
static struct kvmppc_hostwide_stats {
        u64 guest_heap;
        u64 guest_heap_max;
        u64 guest_pgtable_size;
        u64 guest_pgtable_size_max;
        u64 guest_pgtable_reclaim;
} l0_stats;

/* Protect access to l0_stats */
static DEFINE_SPINLOCK(lock_l0_stats);

/* GSB related structs needed to talk to L0 */
static struct kvmppc_gs_msg *gsm_l0_stats;
static struct kvmppc_gs_buff *gsb_l0_stats;
static struct kvmppc_gs_parser gsp_l0_stats;

static struct attribute *kvmppc_pmu_events_attr[] = {
        KVMPPC_PMU_EVENT_ATTR(host_heap, KVMPPC_EVENT_HOST_HEAP),
        KVMPPC_PMU_EVENT_ATTR(host_heap_max, KVMPPC_EVENT_HOST_HEAP_MAX),
        KVMPPC_PMU_EVENT_ATTR(host_pagetable, KVMPPC_EVENT_HOST_PGTABLE),
        KVMPPC_PMU_EVENT_ATTR(host_pagetable_max, KVMPPC_EVENT_HOST_PGTABLE_MAX),
        KVMPPC_PMU_EVENT_ATTR(host_pagetable_reclaim, KVMPPC_EVENT_HOST_PGTABLE_RECLAIM),
        NULL,
};

static const struct attribute_group kvmppc_pmu_events_group = {
        .name = "events",
        .attrs = kvmppc_pmu_events_attr,
};

PMU_FORMAT_ATTR(event, "config:0-5");
static struct attribute *kvmppc_pmu_format_attr[] = {
        &format_attr_event.attr,
        NULL,
};

static struct attribute_group kvmppc_pmu_format_group = {
        .name = "format",
        .attrs = kvmppc_pmu_format_attr,
};

static const struct attribute_group *kvmppc_pmu_attr_groups[] = {
        &kvmppc_pmu_events_group,
        &kvmppc_pmu_format_group,
        NULL,
};

/*
 * Issue the hcall to get the L0-host stats.
 * Should be called with l0-stat lock held
 */
static int kvmppc_update_l0_stats(void)
{
        int rc;

        /* With HOST_WIDE flags guestid and vcpuid will be ignored */
        rc = kvmppc_gsb_recv(gsb_l0_stats, KVMPPC_GS_FLAGS_HOST_WIDE);
        if (rc)
                goto out;

        /* Parse the guest state buffer is successful */
        rc = kvmppc_gse_parse(&gsp_l0_stats, gsb_l0_stats);
        if (rc)
                goto out;

        /* Update the l0 returned stats*/
        memset(&l0_stats, 0, sizeof(l0_stats));
        rc = kvmppc_gsm_refresh_info(gsm_l0_stats, gsb_l0_stats);

out:
        return rc;
}

/* Update the value of the given perf_event */
static int kvmppc_pmu_event_update(struct perf_event *event)
{
        int rc;
        u64 curr_val, prev_val;
        unsigned long flags;
        unsigned int config = event->attr.config;

        /* Ensure no one else is modifying the l0_stats */
        spin_lock_irqsave(&lock_l0_stats, flags);

        rc = kvmppc_update_l0_stats();
        if (!rc) {
                switch (config) {
                case KVMPPC_EVENT_HOST_HEAP:
                        curr_val = l0_stats.guest_heap;
                        break;
                case KVMPPC_EVENT_HOST_HEAP_MAX:
                        curr_val = l0_stats.guest_heap_max;
                        break;
                case KVMPPC_EVENT_HOST_PGTABLE:
                        curr_val = l0_stats.guest_pgtable_size;
                        break;
                case KVMPPC_EVENT_HOST_PGTABLE_MAX:
                        curr_val = l0_stats.guest_pgtable_size_max;
                        break;
                case KVMPPC_EVENT_HOST_PGTABLE_RECLAIM:
                        curr_val = l0_stats.guest_pgtable_reclaim;
                        break;
                default:
                        rc = -ENOENT;
                        break;
                }
        }

        spin_unlock_irqrestore(&lock_l0_stats, flags);

        /* If no error than update the perf event */
        if (!rc) {
                prev_val = local64_xchg(&event->hw.prev_count, curr_val);
                if (curr_val > prev_val)
                        local64_add(curr_val - prev_val, &event->count);
        }

        return rc;
}

static int kvmppc_pmu_event_init(struct perf_event *event)
{
        unsigned int config = event->attr.config;

        pr_debug("%s: Event(%p) id=%llu cpu=%x on_cpu=%x config=%u",
                 __func__, event, event->id, event->cpu,
                 event->oncpu, config);

        if (event->attr.type != event->pmu->type)
                return -ENOENT;

        if (config >= KVMPPC_EVENT_MAX)
                return -EINVAL;

        local64_set(&event->hw.prev_count, 0);
        local64_set(&event->count, 0);

        return 0;
}

static void kvmppc_pmu_del(struct perf_event *event, int flags)
{
        kvmppc_pmu_event_update(event);
}

static int kvmppc_pmu_add(struct perf_event *event, int flags)
{
        if (flags & PERF_EF_START)
                return kvmppc_pmu_event_update(event);
        return 0;
}

static void kvmppc_pmu_read(struct perf_event *event)
{
        kvmppc_pmu_event_update(event);
}

/* Return the size of the needed guest state buffer */
static size_t hostwide_get_size(struct kvmppc_gs_msg *gsm)

{
        size_t size = 0;
        const u16 ids[] = {
                KVMPPC_GSID_L0_GUEST_HEAP,
                KVMPPC_GSID_L0_GUEST_HEAP_MAX,
                KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE,
                KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX,
                KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM
        };

        for (int i = 0; i < ARRAY_SIZE(ids); i++)
                size += kvmppc_gse_total_size(kvmppc_gsid_size(ids[i]));
        return size;
}

/* Populate the request guest state buffer */
static int hostwide_fill_info(struct kvmppc_gs_buff *gsb,
                              struct kvmppc_gs_msg *gsm)
{
        int rc = 0;
        struct kvmppc_hostwide_stats  *stats = gsm->data;

        /*
         * It doesn't matter what values are put into request buffer as
         * they are going to be overwritten anyways. But for the sake of
         * testcode and symmetry contents of existing stats are put
         * populated into the request guest state buffer.
         */
        if (kvmppc_gsm_includes(gsm, KVMPPC_GSID_L0_GUEST_HEAP))
                rc = kvmppc_gse_put_u64(gsb,
                                        KVMPPC_GSID_L0_GUEST_HEAP,
                                        stats->guest_heap);

        if (!rc && kvmppc_gsm_includes(gsm, KVMPPC_GSID_L0_GUEST_HEAP_MAX))
                rc = kvmppc_gse_put_u64(gsb,
                                        KVMPPC_GSID_L0_GUEST_HEAP_MAX,
                                        stats->guest_heap_max);

        if (!rc && kvmppc_gsm_includes(gsm, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE))
                rc = kvmppc_gse_put_u64(gsb,
                                        KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE,
                                        stats->guest_pgtable_size);
        if (!rc &&
            kvmppc_gsm_includes(gsm, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX))
                rc = kvmppc_gse_put_u64(gsb,
                                        KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX,
                                        stats->guest_pgtable_size_max);
        if (!rc &&
            kvmppc_gsm_includes(gsm, KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM))
                rc = kvmppc_gse_put_u64(gsb,
                                        KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM,
                                        stats->guest_pgtable_reclaim);

        return rc;
}

/* Parse and update the host wide stats from returned gsb */
static int hostwide_refresh_info(struct kvmppc_gs_msg *gsm,
                                 struct kvmppc_gs_buff *gsb)
{
        struct kvmppc_gs_parser gsp = { 0 };
        struct kvmppc_hostwide_stats *stats = gsm->data;
        struct kvmppc_gs_elem *gse;
        int rc;

        rc = kvmppc_gse_parse(&gsp, gsb);
        if (rc < 0)
                return rc;

        gse = kvmppc_gsp_lookup(&gsp, KVMPPC_GSID_L0_GUEST_HEAP);
        if (gse)
                stats->guest_heap = kvmppc_gse_get_u64(gse);

        gse = kvmppc_gsp_lookup(&gsp, KVMPPC_GSID_L0_GUEST_HEAP_MAX);
        if (gse)
                stats->guest_heap_max = kvmppc_gse_get_u64(gse);

        gse = kvmppc_gsp_lookup(&gsp, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE);
        if (gse)
                stats->guest_pgtable_size = kvmppc_gse_get_u64(gse);

        gse = kvmppc_gsp_lookup(&gsp, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX);
        if (gse)
                stats->guest_pgtable_size_max = kvmppc_gse_get_u64(gse);

        gse = kvmppc_gsp_lookup(&gsp, KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM);
        if (gse)
                stats->guest_pgtable_reclaim = kvmppc_gse_get_u64(gse);

        return 0;
}

/* gsb-message ops for setting up/parsing */
static struct kvmppc_gs_msg_ops gsb_ops_l0_stats = {
        .get_size = hostwide_get_size,
        .fill_info = hostwide_fill_info,
        .refresh_info = hostwide_refresh_info,
};

static int kvmppc_init_hostwide(void)
{
        int rc = 0;
        unsigned long flags;

        spin_lock_irqsave(&lock_l0_stats, flags);

        /* already registered ? */
        if (gsm_l0_stats) {
                rc = 0;
                goto out;
        }

        /* setup the Guest state message/buffer to talk to L0 */
        gsm_l0_stats = kvmppc_gsm_new(&gsb_ops_l0_stats, &l0_stats,
                                      GSM_SEND, GFP_KERNEL);
        if (!gsm_l0_stats) {
                rc = -ENOMEM;
                goto out;
        }

        /* Populate the Idents */
        kvmppc_gsm_include(gsm_l0_stats, KVMPPC_GSID_L0_GUEST_HEAP);
        kvmppc_gsm_include(gsm_l0_stats, KVMPPC_GSID_L0_GUEST_HEAP_MAX);
        kvmppc_gsm_include(gsm_l0_stats, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE);
        kvmppc_gsm_include(gsm_l0_stats, KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX);
        kvmppc_gsm_include(gsm_l0_stats, KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM);

        /* allocate GSB. Guest/Vcpu Id is ignored */
        gsb_l0_stats = kvmppc_gsb_new(kvmppc_gsm_size(gsm_l0_stats), 0, 0,
                                      GFP_KERNEL);
        if (!gsb_l0_stats) {
                rc = -ENOMEM;
                goto out;
        }

        /* ask the ops to fill in the info */
        rc = kvmppc_gsm_fill_info(gsm_l0_stats, gsb_l0_stats);

out:
        if (rc) {
                if (gsm_l0_stats)
                        kvmppc_gsm_free(gsm_l0_stats);
                if (gsb_l0_stats)
                        kvmppc_gsb_free(gsb_l0_stats);
                gsm_l0_stats = NULL;
                gsb_l0_stats = NULL;
        }
        spin_unlock_irqrestore(&lock_l0_stats, flags);
        return rc;
}

static void kvmppc_cleanup_hostwide(void)
{
        unsigned long flags;

        spin_lock_irqsave(&lock_l0_stats, flags);

        if (gsm_l0_stats)
                kvmppc_gsm_free(gsm_l0_stats);
        if (gsb_l0_stats)
                kvmppc_gsb_free(gsb_l0_stats);
        gsm_l0_stats = NULL;
        gsb_l0_stats = NULL;

        spin_unlock_irqrestore(&lock_l0_stats, flags);
}

/* L1 wide counters PMU */
static struct pmu kvmppc_pmu = {
        .module = THIS_MODULE,
        .task_ctx_nr = perf_sw_context,
        .name = "kvm-hv",
        .event_init = kvmppc_pmu_event_init,
        .add = kvmppc_pmu_add,
        .del = kvmppc_pmu_del,
        .read = kvmppc_pmu_read,
        .attr_groups = kvmppc_pmu_attr_groups,
        .type = -1,
        .scope = PERF_PMU_SCOPE_SYS_WIDE,
        .capabilities = PERF_PMU_CAP_NO_EXCLUDE | PERF_PMU_CAP_NO_INTERRUPT,
};

static int __init kvmppc_register_pmu(void)
{
        int rc = -EOPNOTSUPP;

        /* only support events for nestedv2 right now */
        if (kvmhv_is_nestedv2()) {
                rc = kvmppc_init_hostwide();
                if (rc)
                        goto out;

                /* Register the pmu */
                rc = perf_pmu_register(&kvmppc_pmu, kvmppc_pmu.name, -1);
                if (rc)
                        goto out;

                pr_info("Registered kvm-hv pmu");
        }

out:
        return rc;
}

static void __exit kvmppc_unregister_pmu(void)
{
        if (kvmhv_is_nestedv2()) {
                kvmppc_cleanup_hostwide();

                if (kvmppc_pmu.type != -1)
                        perf_pmu_unregister(&kvmppc_pmu);

                pr_info("kvmhv_pmu unregistered.\n");
        }
}

module_init(kvmppc_register_pmu);
module_exit(kvmppc_unregister_pmu);
MODULE_DESCRIPTION("KVM PPC Book3s-hv PMU");
MODULE_AUTHOR("Vaibhav Jain <vaibhav@linux.ibm.com>");
MODULE_LICENSE("GPL");