mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 10:32:35 +00:00
de7a9e949f
The following build failure occurs when CONFIG_PERF_EVENTS is not set
as generic pmu functions are not visible in that scenario.
|-- s390-randconfig-r044-20220313
| |-- nd_perf.c:(.text):undefined-reference-to-perf_pmu_migrate_context
| |-- nd_perf.c:(.text):undefined-reference-to-perf_pmu_register
| `-- nd_perf.c:(.text):undefined-reference-to-perf_pmu_unregister
Similar build failure in nds32 architecture:
nd_perf.c:(.text+0x21e): undefined reference to `perf_pmu_migrate_context'
nd_perf.c:(.text+0x434): undefined reference to `perf_pmu_register'
nd_perf.c:(.text+0x57c): undefined reference to `perf_pmu_unregister'
Fix this issue by adding check for CONFIG_PERF_EVENTS config option
and disabling the nvdimm perf interface incase this config is not set.
Also remove function declaration of perf_pmu_migrate_context,
perf_pmu_register, perf_pmu_unregister functions from nd.h as these are
common pmu functions which are part of perf_event.h and since we
are disabling nvdimm perf interface incase CONFIG_PERF_EVENTS option
is not set, we not need to declare them in nd.h
Also move the platform_device header file addition part from nd.h to
nd_perf.c and add stub functions for register_nvdimm_pmu and
unregister_nvdimm_pmu functions to handle CONFIG_PERF_EVENTS=n
case.
Fixes: 0fab1ba6ad
("drivers/nvdimm: Add perf interface to expose nvdimm performance stats") (Commit id based on libnvdimm-for-next tree)
Signed-off-by: Kajol Jain <kjain@linux.ibm.com>
Link: https://lore.kernel.org/all/62317124.YBQFU33+s%2FwdvWGj%25lkp@intel.com/
Reported-by: kernel test robot <lkp@intel.com>
Link: https://lore.kernel.org/r/20220323164550.109768-1-kjain@linux.ibm.com
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
330 lines
8.9 KiB
C
330 lines
8.9 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* nd_perf.c: NVDIMM Device Performance Monitoring Unit support
|
|
*
|
|
* Perf interface to expose nvdimm performance stats.
|
|
*
|
|
* Copyright (C) 2021 IBM Corporation
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "nvdimm_pmu: " fmt
|
|
|
|
#include <linux/nd.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#define EVENT(_name, _code) enum{_name = _code}
|
|
|
|
/*
|
|
* NVDIMM Events codes.
|
|
*/
|
|
|
|
/* Controller Reset Count */
|
|
EVENT(CTL_RES_CNT, 0x1);
|
|
/* Controller Reset Elapsed Time */
|
|
EVENT(CTL_RES_TM, 0x2);
|
|
/* Power-on Seconds */
|
|
EVENT(POWERON_SECS, 0x3);
|
|
/* Life Remaining */
|
|
EVENT(MEM_LIFE, 0x4);
|
|
/* Critical Resource Utilization */
|
|
EVENT(CRI_RES_UTIL, 0x5);
|
|
/* Host Load Count */
|
|
EVENT(HOST_L_CNT, 0x6);
|
|
/* Host Store Count */
|
|
EVENT(HOST_S_CNT, 0x7);
|
|
/* Host Store Duration */
|
|
EVENT(HOST_S_DUR, 0x8);
|
|
/* Host Load Duration */
|
|
EVENT(HOST_L_DUR, 0x9);
|
|
/* Media Read Count */
|
|
EVENT(MED_R_CNT, 0xa);
|
|
/* Media Write Count */
|
|
EVENT(MED_W_CNT, 0xb);
|
|
/* Media Read Duration */
|
|
EVENT(MED_R_DUR, 0xc);
|
|
/* Media Write Duration */
|
|
EVENT(MED_W_DUR, 0xd);
|
|
/* Cache Read Hit Count */
|
|
EVENT(CACHE_RH_CNT, 0xe);
|
|
/* Cache Write Hit Count */
|
|
EVENT(CACHE_WH_CNT, 0xf);
|
|
/* Fast Write Count */
|
|
EVENT(FAST_W_CNT, 0x10);
|
|
|
|
NVDIMM_EVENT_ATTR(ctl_res_cnt, CTL_RES_CNT);
|
|
NVDIMM_EVENT_ATTR(ctl_res_tm, CTL_RES_TM);
|
|
NVDIMM_EVENT_ATTR(poweron_secs, POWERON_SECS);
|
|
NVDIMM_EVENT_ATTR(mem_life, MEM_LIFE);
|
|
NVDIMM_EVENT_ATTR(cri_res_util, CRI_RES_UTIL);
|
|
NVDIMM_EVENT_ATTR(host_l_cnt, HOST_L_CNT);
|
|
NVDIMM_EVENT_ATTR(host_s_cnt, HOST_S_CNT);
|
|
NVDIMM_EVENT_ATTR(host_s_dur, HOST_S_DUR);
|
|
NVDIMM_EVENT_ATTR(host_l_dur, HOST_L_DUR);
|
|
NVDIMM_EVENT_ATTR(med_r_cnt, MED_R_CNT);
|
|
NVDIMM_EVENT_ATTR(med_w_cnt, MED_W_CNT);
|
|
NVDIMM_EVENT_ATTR(med_r_dur, MED_R_DUR);
|
|
NVDIMM_EVENT_ATTR(med_w_dur, MED_W_DUR);
|
|
NVDIMM_EVENT_ATTR(cache_rh_cnt, CACHE_RH_CNT);
|
|
NVDIMM_EVENT_ATTR(cache_wh_cnt, CACHE_WH_CNT);
|
|
NVDIMM_EVENT_ATTR(fast_w_cnt, FAST_W_CNT);
|
|
|
|
static struct attribute *nvdimm_events_attr[] = {
|
|
NVDIMM_EVENT_PTR(CTL_RES_CNT),
|
|
NVDIMM_EVENT_PTR(CTL_RES_TM),
|
|
NVDIMM_EVENT_PTR(POWERON_SECS),
|
|
NVDIMM_EVENT_PTR(MEM_LIFE),
|
|
NVDIMM_EVENT_PTR(CRI_RES_UTIL),
|
|
NVDIMM_EVENT_PTR(HOST_L_CNT),
|
|
NVDIMM_EVENT_PTR(HOST_S_CNT),
|
|
NVDIMM_EVENT_PTR(HOST_S_DUR),
|
|
NVDIMM_EVENT_PTR(HOST_L_DUR),
|
|
NVDIMM_EVENT_PTR(MED_R_CNT),
|
|
NVDIMM_EVENT_PTR(MED_W_CNT),
|
|
NVDIMM_EVENT_PTR(MED_R_DUR),
|
|
NVDIMM_EVENT_PTR(MED_W_DUR),
|
|
NVDIMM_EVENT_PTR(CACHE_RH_CNT),
|
|
NVDIMM_EVENT_PTR(CACHE_WH_CNT),
|
|
NVDIMM_EVENT_PTR(FAST_W_CNT),
|
|
NULL
|
|
};
|
|
|
|
static struct attribute_group nvdimm_pmu_events_group = {
|
|
.name = "events",
|
|
.attrs = nvdimm_events_attr,
|
|
};
|
|
|
|
PMU_FORMAT_ATTR(event, "config:0-4");
|
|
|
|
static struct attribute *nvdimm_pmu_format_attr[] = {
|
|
&format_attr_event.attr,
|
|
NULL,
|
|
};
|
|
|
|
static struct attribute_group nvdimm_pmu_format_group = {
|
|
.name = "format",
|
|
.attrs = nvdimm_pmu_format_attr,
|
|
};
|
|
|
|
ssize_t nvdimm_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);
|
|
}
|
|
|
|
static ssize_t nvdimm_pmu_cpumask_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct pmu *pmu = dev_get_drvdata(dev);
|
|
struct nvdimm_pmu *nd_pmu;
|
|
|
|
nd_pmu = container_of(pmu, struct nvdimm_pmu, pmu);
|
|
|
|
return cpumap_print_to_pagebuf(true, buf, cpumask_of(nd_pmu->cpu));
|
|
}
|
|
|
|
static int nvdimm_pmu_cpu_offline(unsigned int cpu, struct hlist_node *node)
|
|
{
|
|
struct nvdimm_pmu *nd_pmu;
|
|
u32 target;
|
|
int nodeid;
|
|
const struct cpumask *cpumask;
|
|
|
|
nd_pmu = hlist_entry_safe(node, struct nvdimm_pmu, node);
|
|
|
|
/* Clear it, incase given cpu is set in nd_pmu->arch_cpumask */
|
|
cpumask_test_and_clear_cpu(cpu, &nd_pmu->arch_cpumask);
|
|
|
|
/*
|
|
* If given cpu is not same as current designated cpu for
|
|
* counter access, just return.
|
|
*/
|
|
if (cpu != nd_pmu->cpu)
|
|
return 0;
|
|
|
|
/* Check for any active cpu in nd_pmu->arch_cpumask */
|
|
target = cpumask_any(&nd_pmu->arch_cpumask);
|
|
|
|
/*
|
|
* Incase we don't have any active cpu in nd_pmu->arch_cpumask,
|
|
* check in given cpu's numa node list.
|
|
*/
|
|
if (target >= nr_cpu_ids) {
|
|
nodeid = cpu_to_node(cpu);
|
|
cpumask = cpumask_of_node(nodeid);
|
|
target = cpumask_any_but(cpumask, cpu);
|
|
}
|
|
nd_pmu->cpu = target;
|
|
|
|
/* Migrate nvdimm pmu events to the new target cpu if valid */
|
|
if (target >= 0 && target < nr_cpu_ids)
|
|
perf_pmu_migrate_context(&nd_pmu->pmu, cpu, target);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int nvdimm_pmu_cpu_online(unsigned int cpu, struct hlist_node *node)
|
|
{
|
|
struct nvdimm_pmu *nd_pmu;
|
|
|
|
nd_pmu = hlist_entry_safe(node, struct nvdimm_pmu, node);
|
|
|
|
if (nd_pmu->cpu >= nr_cpu_ids)
|
|
nd_pmu->cpu = cpu;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int create_cpumask_attr_group(struct nvdimm_pmu *nd_pmu)
|
|
{
|
|
struct perf_pmu_events_attr *pmu_events_attr;
|
|
struct attribute **attrs_group;
|
|
struct attribute_group *nvdimm_pmu_cpumask_group;
|
|
|
|
pmu_events_attr = kzalloc(sizeof(*pmu_events_attr), GFP_KERNEL);
|
|
if (!pmu_events_attr)
|
|
return -ENOMEM;
|
|
|
|
attrs_group = kzalloc(2 * sizeof(struct attribute *), GFP_KERNEL);
|
|
if (!attrs_group) {
|
|
kfree(pmu_events_attr);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Allocate memory for cpumask attribute group */
|
|
nvdimm_pmu_cpumask_group = kzalloc(sizeof(*nvdimm_pmu_cpumask_group), GFP_KERNEL);
|
|
if (!nvdimm_pmu_cpumask_group) {
|
|
kfree(pmu_events_attr);
|
|
kfree(attrs_group);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
sysfs_attr_init(&pmu_events_attr->attr.attr);
|
|
pmu_events_attr->attr.attr.name = "cpumask";
|
|
pmu_events_attr->attr.attr.mode = 0444;
|
|
pmu_events_attr->attr.show = nvdimm_pmu_cpumask_show;
|
|
attrs_group[0] = &pmu_events_attr->attr.attr;
|
|
attrs_group[1] = NULL;
|
|
|
|
nvdimm_pmu_cpumask_group->attrs = attrs_group;
|
|
nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR] = nvdimm_pmu_cpumask_group;
|
|
return 0;
|
|
}
|
|
|
|
static int nvdimm_pmu_cpu_hotplug_init(struct nvdimm_pmu *nd_pmu)
|
|
{
|
|
int nodeid, rc;
|
|
const struct cpumask *cpumask;
|
|
|
|
/*
|
|
* Incase of cpu hotplug feature, arch specific code
|
|
* can provide required cpumask which can be used
|
|
* to get designatd cpu for counter access.
|
|
* Check for any active cpu in nd_pmu->arch_cpumask.
|
|
*/
|
|
if (!cpumask_empty(&nd_pmu->arch_cpumask)) {
|
|
nd_pmu->cpu = cpumask_any(&nd_pmu->arch_cpumask);
|
|
} else {
|
|
/* pick active cpu from the cpumask of device numa node. */
|
|
nodeid = dev_to_node(nd_pmu->dev);
|
|
cpumask = cpumask_of_node(nodeid);
|
|
nd_pmu->cpu = cpumask_any(cpumask);
|
|
}
|
|
|
|
rc = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "perf/nvdimm:online",
|
|
nvdimm_pmu_cpu_online, nvdimm_pmu_cpu_offline);
|
|
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
nd_pmu->cpuhp_state = rc;
|
|
|
|
/* Register the pmu instance for cpu hotplug */
|
|
rc = cpuhp_state_add_instance_nocalls(nd_pmu->cpuhp_state, &nd_pmu->node);
|
|
if (rc) {
|
|
cpuhp_remove_multi_state(nd_pmu->cpuhp_state);
|
|
return rc;
|
|
}
|
|
|
|
/* Create cpumask attribute group */
|
|
rc = create_cpumask_attr_group(nd_pmu);
|
|
if (rc) {
|
|
cpuhp_state_remove_instance_nocalls(nd_pmu->cpuhp_state, &nd_pmu->node);
|
|
cpuhp_remove_multi_state(nd_pmu->cpuhp_state);
|
|
return rc;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void nvdimm_pmu_free_hotplug_memory(struct nvdimm_pmu *nd_pmu)
|
|
{
|
|
cpuhp_state_remove_instance_nocalls(nd_pmu->cpuhp_state, &nd_pmu->node);
|
|
cpuhp_remove_multi_state(nd_pmu->cpuhp_state);
|
|
|
|
if (nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR])
|
|
kfree(nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR]->attrs);
|
|
kfree(nd_pmu->pmu.attr_groups[NVDIMM_PMU_CPUMASK_ATTR]);
|
|
}
|
|
|
|
int register_nvdimm_pmu(struct nvdimm_pmu *nd_pmu, struct platform_device *pdev)
|
|
{
|
|
int rc;
|
|
|
|
if (!nd_pmu || !pdev)
|
|
return -EINVAL;
|
|
|
|
/* event functions like add/del/read/event_init and pmu name should not be NULL */
|
|
if (WARN_ON_ONCE(!(nd_pmu->pmu.event_init && nd_pmu->pmu.add &&
|
|
nd_pmu->pmu.del && nd_pmu->pmu.read && nd_pmu->pmu.name)))
|
|
return -EINVAL;
|
|
|
|
nd_pmu->pmu.attr_groups = kzalloc((NVDIMM_PMU_NULL_ATTR + 1) *
|
|
sizeof(struct attribute_group *), GFP_KERNEL);
|
|
if (!nd_pmu->pmu.attr_groups)
|
|
return -ENOMEM;
|
|
|
|
/*
|
|
* Add platform_device->dev pointer to nvdimm_pmu to access
|
|
* device data in events functions.
|
|
*/
|
|
nd_pmu->dev = &pdev->dev;
|
|
|
|
/* Fill attribute groups for the nvdimm pmu device */
|
|
nd_pmu->pmu.attr_groups[NVDIMM_PMU_FORMAT_ATTR] = &nvdimm_pmu_format_group;
|
|
nd_pmu->pmu.attr_groups[NVDIMM_PMU_EVENT_ATTR] = &nvdimm_pmu_events_group;
|
|
nd_pmu->pmu.attr_groups[NVDIMM_PMU_NULL_ATTR] = NULL;
|
|
|
|
/* Fill attribute group for cpumask */
|
|
rc = nvdimm_pmu_cpu_hotplug_init(nd_pmu);
|
|
if (rc) {
|
|
pr_info("cpu hotplug feature failed for device: %s\n", nd_pmu->pmu.name);
|
|
kfree(nd_pmu->pmu.attr_groups);
|
|
return rc;
|
|
}
|
|
|
|
rc = perf_pmu_register(&nd_pmu->pmu, nd_pmu->pmu.name, -1);
|
|
if (rc) {
|
|
kfree(nd_pmu->pmu.attr_groups);
|
|
nvdimm_pmu_free_hotplug_memory(nd_pmu);
|
|
return rc;
|
|
}
|
|
|
|
pr_info("%s NVDIMM performance monitor support registered\n",
|
|
nd_pmu->pmu.name);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(register_nvdimm_pmu);
|
|
|
|
void unregister_nvdimm_pmu(struct nvdimm_pmu *nd_pmu)
|
|
{
|
|
perf_pmu_unregister(&nd_pmu->pmu);
|
|
nvdimm_pmu_free_hotplug_memory(nd_pmu);
|
|
kfree(nd_pmu);
|
|
}
|
|
EXPORT_SYMBOL_GPL(unregister_nvdimm_pmu);
|