s390/pai: save PAI counter value page in event structure

When the PAI events ALL_CRYPTO or ALL_NNPA are created
for system wide sampling, all PAI counters are monitored.
On each process schedule out, the values of all PAI counters
are investigated. Non-zero values are saved in the event's ring
buffer as raw data. This scheme expects the start value of each counter
to be reset to zero after each read operation performed by the PAI
PMU device driver. This allows for only one active event at any one
time as it relies on the start value of counters to be reset to zero.

Create a save area for each installed PAI XXXX_ALL event and save all
PAI counter values in this save area. Instead of clearing the
PAI counter lowcore area to zero after each read operation,
copy them from the lowcore area to the event's save area at process
schedule out time.
The delta of each PAI counter is calculated by subtracting the
old counter's value stored in the event's save area from the current
value stored in the lowcore area.

With this scheme, mulitple events of the PAI counters XXXX_ALL
can be handled at the same time. This will be addressed in a
follow-on patch.

Signed-off-by: Thomas Richter <tmricht@linux.ibm.com>
Acked-by: Sumanth Korikkar <sumanthk@linux.ibm.com>
Signed-off-by: Heiko Carstens <hca@linux.ibm.com>

diff --git a/arch/s390/include/asm/pai.h b/arch/s390/include/asm/pai.h
index 7d1888e3dee6a670f1ec25cc2ac71640f06fd5b6..c60123d3ad74794e97b75828c9ffcb961a0aa8eb 100644 (file)
--- a/arch/s390/include/asm/pai.h
+++ b/arch/s390/include/asm/pai.h
@@ -81,4 +81,5 @@ enum paievt_mode {
        PAI_MODE_COUNTING,
 };
 
+#define PAI_SAVE_AREA(x)       ((x)->hw.event_base)
 #endif

diff --git a/arch/s390/kernel/perf_pai_crypto.c b/arch/s390/kernel/perf_pai_crypto.c
index 7e7472aee4e56bcc5d98f71f81b8bfcdd55d444f..8c98bd493707251cd7c4e07db48405468bc6efdb 100644 (file)
--- a/arch/s390/kernel/perf_pai_crypto.c
+++ b/arch/s390/kernel/perf_pai_crypto.c
@@ -98,6 +98,7 @@ static void paicrypt_event_destroy(struct perf_event *event)
                            event->attr.config, event->cpu,
                            cpump->active_events, cpump->mode,
                            refcount_read(&cpump->refcnt));
+       free_page(PAI_SAVE_AREA(event));
        if (refcount_dec_and_test(&cpump->refcnt)) {
                debug_sprintf_event(cfm_dbg, 4, "%s page %#lx save %p\n",
                                    __func__, (unsigned long)cpump->page,
@@ -260,6 +261,7 @@ static int paicrypt_event_init(struct perf_event *event)
 {
        struct perf_event_attr *a = &event->attr;
        struct paicrypt_map *cpump;
+       int rc = 0;
 
        /* PAI crypto PMU registered as PERF_TYPE_RAW, check event type */
        if (a->type != PERF_TYPE_RAW && event->pmu->type != a->type)
@@ -274,10 +276,21 @@ static int paicrypt_event_init(struct perf_event *event)
        /* Allow only CRYPTO_ALL for sampling. */
        if (a->sample_period && a->config != PAI_CRYPTO_BASE)
                return -EINVAL;
+       /* Get a page to store last counter values for sampling */
+       if (a->sample_period) {
+               PAI_SAVE_AREA(event) = get_zeroed_page(GFP_KERNEL);
+               if (!PAI_SAVE_AREA(event)) {
+                       rc = -ENOMEM;
+                       goto out;
+               }
+       }
 
        cpump = paicrypt_busy(event);
-       if (IS_ERR(cpump))
-               return PTR_ERR(cpump);
+       if (IS_ERR(cpump)) {
+               free_page(PAI_SAVE_AREA(event));
+               rc = PTR_ERR(cpump);
+               goto out;
+       }
 
        event->destroy = paicrypt_event_destroy;
 
@@ -293,7 +306,8 @@ static int paicrypt_event_init(struct perf_event *event)
        }
 
        static_branch_inc(&pai_key);
-       return 0;
+out:
+       return rc;
 }
 
 static void paicrypt_read(struct perf_event *event)
@@ -367,23 +381,34 @@ static void paicrypt_del(struct perf_event *event, int flags)
        }
 }
 
-/* Create raw data and save it in buffer. Returns number of bytes copied.
- * Saves only positive counter entries of the form
+/* Create raw data and save it in buffer. Calculate the delta for each
+ * counter between this invocation and the last invocation.
+ * Returns number of bytes copied.
+ * Saves only entries with positive counter difference of the form
  * 2 bytes: Number of counter
  * 8 bytes: Value of counter
  */
 static size_t paicrypt_copy(struct pai_userdata *userdata, unsigned long *page,
-                           bool exclude_user, bool exclude_kernel)
+                           unsigned long *page_old, bool exclude_user,
+                           bool exclude_kernel)
 {
        int i, outidx = 0;
 
        for (i = 1; i <= paicrypt_cnt; i++) {
-               u64 val = 0;
+               u64 val = 0, val_old = 0;
 
-               if (!exclude_kernel)
+               if (!exclude_kernel) {
                        val += paicrypt_getctr(page, i, true);
-               if (!exclude_user)
+                       val_old += paicrypt_getctr(page_old, i, true);
+               }
+               if (!exclude_user) {
                        val += paicrypt_getctr(page, i, false);
+                       val_old += paicrypt_getctr(page_old, i, false);
+               }
+               if (val >= val_old)
+                       val -= val_old;
+               else
+                       val = (~0ULL - val_old) + val + 1;
                if (val) {
                        userdata[outidx].num = i;
                        userdata[outidx].value = val;
@@ -426,8 +451,8 @@ static int paicrypt_push_sample(size_t rawsize, struct paicrypt_map *cpump,
 
        overflow = perf_event_overflow(event, &data, &regs);
        perf_event_update_userpage(event);
-       /* Clear lowcore page after read */
-       memset(cpump->page, 0, PAGE_SIZE);
+       /* Save crypto counter lowcore page after reading event data. */
+       memcpy((void *)PAI_SAVE_AREA(event), cpump->page, PAGE_SIZE);
        return overflow;
 }
 
@@ -443,6 +468,7 @@ static int paicrypt_have_sample(void)
        if (!event)             /* No event active */
                return 0;
        rawsize = paicrypt_copy(cpump->save, cpump->page,
+                               (unsigned long *)PAI_SAVE_AREA(event),
                                cpump->event->attr.exclude_user,
                                cpump->event->attr.exclude_kernel);
        if (rawsize)                    /* No incremented counters */

diff --git a/arch/s390/kernel/perf_pai_ext.c b/arch/s390/kernel/perf_pai_ext.c
index 4d86130bcf14442ce353176bc327f7453d365aa2..21a18eafb5767ef7420d62eb109248b56114931f 100644 (file)
--- a/arch/s390/kernel/perf_pai_ext.c
+++ b/arch/s390/kernel/perf_pai_ext.c
@@ -120,6 +120,7 @@ static void paiext_event_destroy(struct perf_event *event)
        struct paiext_mapptr *mp = per_cpu_ptr(paiext_root.mapptr, event->cpu);
        struct paiext_map *cpump = mp->mapptr;
 
+       free_page(PAI_SAVE_AREA(event));
        mutex_lock(&paiext_reserve_mutex);
        cpump->event = NULL;
        if (refcount_dec_and_test(&cpump->refcnt))      /* Last reference gone */
@@ -256,10 +257,18 @@ static int paiext_event_init(struct perf_event *event)
        /* Prohibit exclude_user event selection */
        if (a->exclude_user)
                return -EINVAL;
+       /* Get a page to store last counter values for sampling */
+       if (a->sample_period) {
+               PAI_SAVE_AREA(event) = get_zeroed_page(GFP_KERNEL);
+               if (!PAI_SAVE_AREA(event))
+                       return -ENOMEM;
+       }
 
        rc = paiext_alloc(a, event);
-       if (rc)
+       if (rc) {
+               free_page(PAI_SAVE_AREA(event));
                return rc;
+       }
        event->destroy = paiext_event_destroy;
 
        if (a->sample_period) {
@@ -384,13 +393,19 @@ static void paiext_del(struct perf_event *event, int flags)
  * 2 bytes: Number of counter
  * 8 bytes: Value of counter
  */
-static size_t paiext_copy(struct pai_userdata *userdata, unsigned long *area)
+static size_t paiext_copy(struct pai_userdata *userdata, unsigned long *area,
+                         unsigned long *area_old)
 {
        int i, outidx = 0;
 
        for (i = 1; i <= paiext_cnt; i++) {
                u64 val = paiext_getctr(area, i);
+               u64 val_old = paiext_getctr(area_old, i);
 
+               if (val >= val_old)
+                       val -= val_old;
+               else
+                       val = (~0ULL - val_old) + val + 1;
                if (val) {
                        userdata[outidx].num = i;
                        userdata[outidx].value = val;
@@ -446,8 +461,9 @@ static int paiext_push_sample(size_t rawsize, struct paiext_map *cpump,
 
        overflow = perf_event_overflow(event, &data, &regs);
        perf_event_update_userpage(event);
-       /* Clear lowcore area after read */
-       memset(cpump->area, 0, PAIE1_CTRBLOCK_SZ);
+       /* Save NNPA lowcore area after read in event */
+       memcpy((void *)PAI_SAVE_AREA(event), cpump->area,
+              PAIE1_CTRBLOCK_SZ);
        return overflow;
 }
 
@@ -462,7 +478,8 @@ static int paiext_have_sample(void)
 
        if (!event)
                return 0;
-       rawsize = paiext_copy(cpump->save, cpump->area);
+       rawsize = paiext_copy(cpump->save, cpump->area,
+                             (unsigned long *)PAI_SAVE_AREA(event));
        if (rawsize)                    /* Incremented counters */
                rc = paiext_push_sample(rawsize, cpump, event);
        return rc;