powerpc/perf/24x7: Eliminate domain suffix in event names

The Physical Core events of the 24x7 PMU can be monitored across various
domains (physical core, vcpu home core, vcpu home node etc). For each of
these core events, we currently create multiple events in sysfs, one for
each domain the event can be monitored in. These events are distinguished
by their suffixes like __PHYS_CORE, __VCPU_HOME_CORE etc.

Rather than creating multiple such entries, we could let the user specify
make 'domain' index a required parameter and let the user specify a value
for it (like they currently specify the core index).

	$ cat /sys/bus/event_source/devices/hv_24x7/events/HPM_CCYC
	domain=?,offset=0x98,core=?,lpar=0x0

	$ perf stat -C 0 -e hv_24x7/HPM_CCYC,domain=2,core=1/ true

(the 'domain=?' and 'core=?' in sysfs tell perf tool to enforce them as
required parameters).

This simplifies the interface and allows users to identify events by the
name specified in the catalog (User can determine the domain index by
referring to '/sys/bus/event_source/devices/hv_24x7/interface/domains').

Eliminating the event suffix eliminates several functions and simplifies
code.

Note that Physical Chip events can only be monitored in the chip domain
so those events have the domain set to 1 (rather than =?) and users don't
need to specify the domain index for the Chip events.

	$ cat /sys/bus/event_source/devices/hv_24x7/events/PM_XLINK_CYCLES
	domain=1,offset=0x230,chip=?,lpar=0x0

	$ perf stat -C 0 -e hv_24x7/PM_XLINK_CYCLES,chip=1/ true

Signed-off-by: Sukadev Bhattiprolu <sukadev@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>

1 files changed, 66 insertions, 83 deletions

diff --git a/arch/powerpc/perf/hv-24x7.c b/arch/powerpc/perf/hv-24x7.c
index 36b29fd9295d..59012e750abe 100644
--- a/arch/powerpc/perf/hv-24x7.c
+++ b/arch/powerpc/perf/hv-24x7.c
@@ -27,20 +27,6 @@
 #include "hv-24x7-catalog.h"
 #include "hv-common.h"
 
-static const char *event_domain_suffix(unsigned domain)
-{
-        switch (domain) {
-#define DOMAIN(n, v, x, c)              \
-        case HV_PERF_DOMAIN_##n:        \
-                return "__" #n;
-#include "hv-24x7-domains.h"
-#undef DOMAIN
-        default:
-                WARN(1, "unknown domain %d\n", domain);
-                return "__UNKNOWN_DOMAIN_SUFFIX";
-        }
-}
-
 static bool domain_is_valid(unsigned domain)
 {
         switch (domain) {
@@ -294,38 +280,70 @@ static unsigned long h_get_24x7_catalog_page(char page[],
                                         version, index);
 }
 
-static unsigned core_domains[] = {
-        HV_PERF_DOMAIN_PHYS_CORE,
-        HV_PERF_DOMAIN_VCPU_HOME_CORE,
-        HV_PERF_DOMAIN_VCPU_HOME_CHIP,
-        HV_PERF_DOMAIN_VCPU_HOME_NODE,
-        HV_PERF_DOMAIN_VCPU_REMOTE_NODE,
-};
-/* chip event data always yeilds a single event, core yeilds multiple */
-#define MAX_EVENTS_PER_EVENT_DATA ARRAY_SIZE(core_domains)
-
+/*
+ * Each event we find in the catalog, will have a sysfs entry. Format the
+ * data for this sysfs entry based on the event's domain.
+ *
+ * Events belonging to the Chip domain can only be monitored in that domain.
+ * i.e the domain for these events is a fixed/knwon value.
+ *
+ * Events belonging to the Core domain can be monitored either in the physical
+ * core or in one of the virtual CPU domains. So the domain value for these
+ * events must be specified by the user (i.e is a required parameter). Format
+ * the Core events with 'domain=?' so the perf-tool can error check required
+ * parameters.
+ *
+ * NOTE: For the Core domain events, rather than making domain a required
+ *       parameter we could default it to PHYS_CORE and allowe users to
+ *       override the domain to one of the VCPU domains.
+ *
+ *       However, this can make the interface a little inconsistent.
+ *
+ *       If we set domain=2 (PHYS_CHIP) and allow user to override this field
+ *       the user may be tempted to also modify the "offset=x" field in which
+ *       can lead to confusing usage. Consider the HPM_PCYC (offset=0x18) and
+ *       HPM_INST (offset=0x20) events. With:
+ *
+ *              perf stat -e hv_24x7/HPM_PCYC,offset=0x20/
+ *
+ *      we end up monitoring HPM_INST, while the command line has HPM_PCYC.
+ *
+ *      By not assigning a default value to the domain for the Core events,
+ *      we can have simple guidelines:
+ *
+ *              - Specifying values for parameters with "=?" is required.
+ *
+ *              - Specifying (i.e overriding) values for other parameters
+ *                is undefined.
+ */
 static char *event_fmt(struct hv_24x7_event_data *event, unsigned domain)
 {
         const char *sindex;
         const char *lpar;
+        const char *domain_str;
+        char buf[8];
 
         switch (domain) {
         case HV_PERF_DOMAIN_PHYS_CHIP:
+                snprintf(buf, sizeof(buf), "%d", domain);
+                domain_str = buf;
                 lpar = "0x0";
                 sindex = "chip";
                 break;
         case HV_PERF_DOMAIN_PHYS_CORE:
+                domain_str = "?";
                 lpar = "0x0";
                 sindex = "core";
                 break;
         default:
+                domain_str = "?";
                 lpar = "?";
                 sindex = "vcpu";
         }
 
         return kasprintf(GFP_KERNEL,
-                        "domain=0x%x,offset=0x%x,%s=?,lpar=%s",
-                        domain,
+                        "domain=%s,offset=0x%x,%s=?,lpar=%s",
+                        domain_str,
                         be16_to_cpu(event->event_counter_offs) +
                                 be16_to_cpu(event->event_group_record_offs),
                         sindex,
@@ -365,6 +383,15 @@ static struct attribute *device_str_attr_create_(char *name, char *str)
         return &attr->attr.attr;
 }
 
+/*
+ * Allocate and initialize strings representing event attributes.
+ *
+ * NOTE: The strings allocated here are never destroyed and continue to
+ *       exist till shutdown. This is to allow us to create as many events
+ *       from the catalog as possible, even if we encounter errors with some.
+ *       In case of changes to error paths in future, these may need to be
+ *       freed by the caller.
+ */
 static struct attribute *device_str_attr_create(char *name, int name_max,
                                                 int name_nonce,
                                                 char *str, size_t str_max)
@@ -396,16 +423,6 @@ out_s:
         return NULL;
 }
 
-static void device_str_attr_destroy(struct attribute *attr)
-{
-        struct dev_ext_attribute *d;
-
-        d = container_of(attr, struct dev_ext_attribute, attr.attr);
-        kfree(d->var);
-        kfree(d->attr.attr.name);
-        kfree(d);
-}
-
 static struct attribute *event_to_attr(unsigned ix,
                                        struct hv_24x7_event_data *event,
                                        unsigned domain,
@@ -413,7 +430,6 @@ static struct attribute *event_to_attr(unsigned ix,
 {
         int event_name_len;
         char *ev_name, *a_ev_name, *val;
-        const char *ev_suffix;
         struct attribute *attr;
 
         if (!domain_is_valid(domain)) {
@@ -426,14 +442,13 @@ static struct attribute *event_to_attr(unsigned ix,
         if (!val)
                 return NULL;
 
-        ev_suffix = event_domain_suffix(domain);
         ev_name = event_name(event, &event_name_len);
         if (!nonce)
-                a_ev_name = kasprintf(GFP_KERNEL, "%.*s%s",
-                                (int)event_name_len, ev_name, ev_suffix);
+                a_ev_name = kasprintf(GFP_KERNEL, "%.*s",
+                                (int)event_name_len, ev_name);
         else
-                a_ev_name = kasprintf(GFP_KERNEL, "%.*s%s__%d",
-                                (int)event_name_len, ev_name, ev_suffix, nonce);
+                a_ev_name = kasprintf(GFP_KERNEL, "%.*s__%d",
+                                (int)event_name_len, ev_name, nonce);
 
         if (!a_ev_name)
                 goto out_val;
@@ -478,45 +493,14 @@ event_to_long_desc_attr(struct hv_24x7_event_data *event, int nonce)
         return device_str_attr_create(name, nl, nonce, desc, dl);
 }
 
-static ssize_t event_data_to_attrs(unsigned ix, struct attribute **attrs,
+static int event_data_to_attrs(unsigned ix, struct attribute **attrs,
                                    struct hv_24x7_event_data *event, int nonce)
 {
-        unsigned i;
-
-        switch (event->domain) {
-        case HV_PERF_DOMAIN_PHYS_CHIP:
-                *attrs = event_to_attr(ix, event, event->domain, nonce);
-                return 1;
-        case HV_PERF_DOMAIN_PHYS_CORE:
-                for (i = 0; i < ARRAY_SIZE(core_domains); i++) {
-                        attrs[i] = event_to_attr(ix, event, core_domains[i],
-                                                nonce);
-                        if (!attrs[i]) {
-                                pr_warn("catalog event %u: individual attr %u "
-                                        "creation failure\n", ix, i);
-                                for (; i; i--)
-                                        device_str_attr_destroy(attrs[i - 1]);
-                                return -1;
-                        }
-                }
-                return i;
-        default:
-                pr_warn("catalog event %u: domain %u is not allowed in the "
-                                "catalog\n", ix, event->domain);
+        *attrs = event_to_attr(ix, event, event->domain, nonce);
+        if (!*attrs)
                 return -1;
-        }
-}
 
-static size_t event_to_attr_ct(struct hv_24x7_event_data *event)
-{
-        switch (event->domain) {
-        case HV_PERF_DOMAIN_PHYS_CHIP:
-                return 1;
-        case HV_PERF_DOMAIN_PHYS_CORE:
-                return ARRAY_SIZE(core_domains);
-        default:
-                return 0;
-        }
+        return 0;
 }
 
 static unsigned long vmalloc_to_phys(void *v)
@@ -752,9 +736,8 @@ static int create_events_from_catalog(struct attribute ***events_,
                 goto e_free;
         }
 
-        if (SIZE_MAX / MAX_EVENTS_PER_EVENT_DATA - 1 < event_entry_count) {
-                pr_err("event_entry_count %zu is invalid\n",
-                                event_entry_count);
+        if (SIZE_MAX - 1 < event_entry_count) {
+                pr_err("event_entry_count %zu is invalid\n", event_entry_count);
                 ret = -EIO;
                 goto e_free;
         }
@@ -827,7 +810,7 @@ static int create_events_from_catalog(struct attribute ***events_,
                         continue;
                 }
 
-                attr_max += event_to_attr_ct(event);
+                attr_max++;
         }
 
         event_idx_last = event_idx;
@@ -877,12 +860,12 @@ static int create_events_from_catalog(struct attribute ***events_,
                 nonce = event_uniq_add(&ev_uniq, name, nl, event->domain);
                 ct    = event_data_to_attrs(event_idx, events + event_attr_ct,
                                             event, nonce);
-                if (ct <= 0) {
+                if (ct < 0) {
                         pr_warn("event %zu (%.*s) creation failure, skipping\n",
                                 event_idx, nl, name);
                         junk_events++;
                 } else {
-                        event_attr_ct += ct;
+                        event_attr_ct++;
                         event_descs[desc_ct] = event_to_desc_attr(event, nonce);
                         if (event_descs[desc_ct])
                                 desc_ct++;