public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-08-05 16:54:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
linux/arch/powerpc/perf/kvm-hv-pmu.c
Vaibhav Jain 02a1324b08 powerpc/kvm-hv-pmu: Add perf-events for Hostwide counters 
Update 'kvm-hv-pmu.c' to add five new perf-events mapped to the five
Hostwide counters. Since these newly introduced perf events are at system
wide scope and can be read from any L1-Lpar CPU, 'kvmppc_pmu' scope and
capabilities are updated appropriately.

Also introduce two new helpers. First is kvmppc_update_l0_stats() that uses
the infrastructure introduced in previous patches to issues the
H_GUEST_GET_STATE hcall L0-PowerVM to fetch guest-state-buffer holding the
latest values of these counters which is then parsed and 'l0_stats'
variable updated.

Second helper is kvmppc_pmu_event_update() which is called from
'kvmppv_pmu' callbacks and uses kvmppc_update_l0_stats() to update
'l0_stats' and the update the 'struct perf_event's event-counter.

Some minor updates to kvmppc_pmu_{add, del, read}() to remove some debug
scaffolding code.

Signed-off-by: Vaibhav Jain <vaibhav@linux.ibm.com>
Reviewed-by: Athira Rajeev <atrajeev@linux.ibm.com>
Signed-off-by: Madhavan Srinivasan <maddy@linux.ibm.com>
Link: https://patch.msgid.link/20250416162740.93143-7-vaibhav@linux.ibm.com
2025-04-16 22:16:10 +05:30

435 lines
11 KiB
C
Raw Permalink Blame History

// 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");
Reference in a new issue View git blame Copy permalink