arch/powerpc/perf/hv-gpci.c

   1 /*
   2  * Hypervisor supplied "gpci" ("get performance counter info") performance
   3  * counter support
   4  *
   5  * Author: Cody P Schafer <cody@linux.vnet.ibm.com>
   6  * Copyright 2014 IBM Corporation.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version
  11  * 2 of the License, or (at your option) any later version.
  12  */
  13
  14 #define pr_fmt(fmt) "hv-gpci: " fmt
  15
  16 #include <linux/init.h>
  17 #include <linux/perf_event.h>
  18 #include <asm/firmware.h>
  19 #include <asm/hvcall.h>
  20 #include <asm/io.h>
  21
  22 #include "hv-gpci.h"
  23 #include "hv-common.h"
  24
  25 /*
  26  * Example usage:
  27  *  perf stat -e 'hv_gpci/counter_info_version=3,offset=0,length=8,
  28  *                secondary_index=0,starting_index=0xffffffff,request=0x10/' ...
  29  */
  30
  31 /* u32 */
  32 EVENT_DEFINE_RANGE_FORMAT(request, config, 0, 31);
  33 /* u32 */
  34 /*
  35  * Note that starting_index, phys_processor_idx, sibling_part_id,
  36  * hw_chip_id, partition_id all refer to the same bit range. They
  37  * are basically aliases for the starting_index. The specific alias
  38  * used depends on the event. See REQUEST_IDX_KIND in hv-gpci-requests.h
  39  */
  40 EVENT_DEFINE_RANGE_FORMAT(starting_index, config, 32, 63);
  41 EVENT_DEFINE_RANGE_FORMAT_LITE(phys_processor_idx, config, 32, 63);
  42 EVENT_DEFINE_RANGE_FORMAT_LITE(sibling_part_id, config, 32, 63);
  43 EVENT_DEFINE_RANGE_FORMAT_LITE(hw_chip_id, config, 32, 63);
  44 EVENT_DEFINE_RANGE_FORMAT_LITE(partition_id, config, 32, 63);
  45
  46 /* u16 */
  47 EVENT_DEFINE_RANGE_FORMAT(secondary_index, config1, 0, 15);
  48 /* u8 */
  49 EVENT_DEFINE_RANGE_FORMAT(counter_info_version, config1, 16, 23);
  50 /* u8, bytes of data (1-8) */
  51 EVENT_DEFINE_RANGE_FORMAT(length, config1, 24, 31);
  52 /* u32, byte offset */
  53 EVENT_DEFINE_RANGE_FORMAT(offset, config1, 32, 63);
  54
  55 static struct attribute *format_attrs[] = {
  56         &format_attr_request.attr,
  57         &format_attr_starting_index.attr,
  58         &format_attr_phys_processor_idx.attr,
  59         &format_attr_sibling_part_id.attr,
  60         &format_attr_hw_chip_id.attr,
  61         &format_attr_partition_id.attr,
  62         &format_attr_secondary_index.attr,
  63         &format_attr_counter_info_version.attr,
  64
  65         &format_attr_offset.attr,
  66         &format_attr_length.attr,
  67         NULL,
  68 };
  69
  70 static struct attribute_group format_group = {
  71         .name = "format",
  72         .attrs = format_attrs,
  73 };
  74
  75 static struct attribute_group event_group = {
  76         .name  = "events",
  77         .attrs = hv_gpci_event_attrs,
  78 };
  79
  80 #define HV_CAPS_ATTR(_name, _format)                            \
  81 static ssize_t _name##_show(struct device *dev,                 \
  82                             struct device_attribute *attr,      \
  83                             char *page)                         \
  84 {                                                               \
  85         struct hv_perf_caps caps;                               \
  86         unsigned long hret = hv_perf_caps_get(&caps);           \
  87         if (hret)                                               \
  88                 return -EIO;                                    \
  89                                                                 \
  90         return sprintf(page, _format, caps._name);              \
  91 }                                                               \
  92 static struct device_attribute hv_caps_attr_##_name = __ATTR_RO(_name)
  93
  94 static ssize_t kernel_version_show(struct device *dev,
  95                                    struct device_attribute *attr,
  96                                    char *page)
  97 {
  98         return sprintf(page, "0x%x\n", COUNTER_INFO_VERSION_CURRENT);
  99 }
 100
 101 static DEVICE_ATTR_RO(kernel_version);
 102 HV_CAPS_ATTR(version, "0x%x\n");
 103 HV_CAPS_ATTR(ga, "%d\n");
 104 HV_CAPS_ATTR(expanded, "%d\n");
 105 HV_CAPS_ATTR(lab, "%d\n");
 106 HV_CAPS_ATTR(collect_privileged, "%d\n");
 107
 108 static struct attribute *interface_attrs[] = {
 109         &dev_attr_kernel_version.attr,
 110         &hv_caps_attr_version.attr,
 111         &hv_caps_attr_ga.attr,
 112         &hv_caps_attr_expanded.attr,
 113         &hv_caps_attr_lab.attr,
 114         &hv_caps_attr_collect_privileged.attr,
 115         NULL,
 116 };
 117
 118 static struct attribute_group interface_group = {
 119         .name = "interface",
 120         .attrs = interface_attrs,
 121 };
 122
 123 static const struct attribute_group *attr_groups[] = {
 124         &format_group,
 125         &event_group,
 126         &interface_group,
 127         NULL,
 128 };
 129
 130 #define HGPCI_REQ_BUFFER_SIZE   4096
 131 #define HGPCI_MAX_DATA_BYTES \
 132         (HGPCI_REQ_BUFFER_SIZE - sizeof(struct hv_get_perf_counter_info_params))
 133
 134 static DEFINE_PER_CPU(char, hv_gpci_reqb[HGPCI_REQ_BUFFER_SIZE]) __aligned(sizeof(uint64_t));
 135
 136 struct hv_gpci_request_buffer {
 137         struct hv_get_perf_counter_info_params params;
 138         uint8_t bytes[HGPCI_MAX_DATA_BYTES];
 139 } __packed;
 140
 141 static unsigned long single_gpci_request(u32 req, u32 starting_index,
 142                 u16 secondary_index, u8 version_in, u32 offset, u8 length,
 143                 u64 *value)
 144 {
 145         unsigned long ret;
 146         size_t i;
 147         u64 count;
 148         struct hv_gpci_request_buffer *arg;
 149
 150         arg = (void *)get_cpu_var(hv_gpci_reqb);
 151         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 152
 153         arg->params.counter_request = cpu_to_be32(req);
 154         arg->params.starting_index = cpu_to_be32(starting_index);
 155         arg->params.secondary_index = cpu_to_be16(secondary_index);
 156         arg->params.counter_info_version_in = version_in;
 157
 158         ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 159                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 160         if (ret) {
 161                 pr_devel("hcall failed: 0x%lx\n", ret);
 162                 goto out;
 163         }
 164
 165         /*
 166          * we verify offset and length are within the zeroed buffer at event
 167          * init.
 168          */
 169         count = 0;
 170         for (i = offset; i < offset + length; i++)
 171                 count |= arg->bytes[i] << (i - offset);
 172
 173         *value = count;
 174 out:
 175         put_cpu_var(hv_gpci_reqb);
 176         return ret;
 177 }
 178
 179 static u64 h_gpci_get_value(struct perf_event *event)
 180 {
 181         u64 count;
 182         unsigned long ret = single_gpci_request(event_get_request(event),
 183                                         event_get_starting_index(event),
 184                                         event_get_secondary_index(event),
 185                                         event_get_counter_info_version(event),
 186                                         event_get_offset(event),
 187                                         event_get_length(event),
 188                                         &count);
 189         if (ret)
 190                 return 0;
 191         return count;
 192 }
 193
 194 static void h_gpci_event_update(struct perf_event *event)
 195 {
 196         s64 prev;
 197         u64 now = h_gpci_get_value(event);
 198         prev = local64_xchg(&event->hw.prev_count, now);
 199         local64_add(now - prev, &event->count);
 200 }
 201
 202 static void h_gpci_event_start(struct perf_event *event, int flags)
 203 {
 204         local64_set(&event->hw.prev_count, h_gpci_get_value(event));
 205 }
 206
 207 static void h_gpci_event_stop(struct perf_event *event, int flags)
 208 {
 209         h_gpci_event_update(event);
 210 }
 211
 212 static int h_gpci_event_add(struct perf_event *event, int flags)
 213 {
 214         if (flags & PERF_EF_START)
 215                 h_gpci_event_start(event, flags);
 216
 217         return 0;
 218 }
 219
 220 static int h_gpci_event_init(struct perf_event *event)
 221 {
 222         u64 count;
 223         u8 length;
 224
 225         /* Not our event */
 226         if (event->attr.type != event->pmu->type)
 227                 return -ENOENT;
 228
 229         /* config2 is unused */
 230         if (event->attr.config2) {
 231                 pr_devel("config2 set when reserved\n");
 232                 return -EINVAL;
 233         }
 234
 235         /* unsupported modes and filters */
 236         if (event->attr.exclude_user   ||
 237             event->attr.exclude_kernel ||
 238             event->attr.exclude_hv     ||
 239             event->attr.exclude_idle   ||
 240             event->attr.exclude_host   ||
 241             event->attr.exclude_guest)
 242                 return -EINVAL;
 243
 244         /* no branch sampling */
 245         if (has_branch_stack(event))
 246                 return -EOPNOTSUPP;
 247
 248         length = event_get_length(event);
 249         if (length < 1 || length > 8) {
 250                 pr_devel("length invalid\n");
 251                 return -EINVAL;
 252         }
 253
 254         /* last byte within the buffer? */
 255         if ((event_get_offset(event) + length) > HGPCI_MAX_DATA_BYTES) {
 256                 pr_devel("request outside of buffer: %zu > %zu\n",
 257                                 (size_t)event_get_offset(event) + length,
 258                                 HGPCI_MAX_DATA_BYTES);
 259                 return -EINVAL;
 260         }
 261
 262         /* check if the request works... */
 263         if (single_gpci_request(event_get_request(event),
 264                                 event_get_starting_index(event),
 265                                 event_get_secondary_index(event),
 266                                 event_get_counter_info_version(event),
 267                                 event_get_offset(event),
 268                                 length,
 269                                 &count)) {
 270                 pr_devel("gpci hcall failed\n");
 271                 return -EINVAL;
 272         }
 273
 274         return 0;
 275 }
 276
 277 static struct pmu h_gpci_pmu = {
 278         .task_ctx_nr = perf_invalid_context,
 279
 280         .name = "hv_gpci",
 281         .attr_groups = attr_groups,
 282         .event_init  = h_gpci_event_init,
 283         .add         = h_gpci_event_add,
 284         .del         = h_gpci_event_stop,
 285         .start       = h_gpci_event_start,
 286         .stop        = h_gpci_event_stop,
 287         .read        = h_gpci_event_update,
 288 };
 289
 290 static int hv_gpci_init(void)
 291 {
 292         int r;
 293         unsigned long hret;
 294         struct hv_perf_caps caps;
 295
 296         hv_gpci_assert_offsets_correct();
 297
 298         if (!firmware_has_feature(FW_FEATURE_LPAR)) {
 299                 pr_debug("not a virtualized system, not enabling\n");
 300                 return -ENODEV;
 301         }
 302
 303         hret = hv_perf_caps_get(&caps);
 304         if (hret) {
 305                 pr_debug("could not obtain capabilities, not enabling, rc=%ld\n",
 306                                 hret);
 307                 return -ENODEV;
 308         }
 309
 310         /* sampling not supported */
 311         h_gpci_pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;
 312
 313         r = perf_pmu_register(&h_gpci_pmu, h_gpci_pmu.name, -1);
 314         if (r)
 315                 return r;
 316
 317         return 0;
 318 }
 319
 320 device_initcall(hv_gpci_init);