Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 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 */ |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 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 | */ |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 40 | EVENT_DEFINE_RANGE_FORMAT(starting_index, config, 32, 63); |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 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 | |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 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, |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 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, |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 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 | |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 75 | static struct attribute_group event_group = { |
| 76 | .name = "events", |
| 77 | .attrs = hv_gpci_event_attrs, |
| 78 | }; |
| 79 | |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 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 | |
Cody P Schafer | 58a685c | 2014-04-15 10:10:52 -0700 | [diff] [blame] | 101 | static DEVICE_ATTR_RO(kernel_version); |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 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, |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 125 | &event_group, |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 126 | &interface_group, |
| 127 | NULL, |
| 128 | }; |
| 129 | |
| 130 | #define GPCI_MAX_DATA_BYTES \ |
| 131 | (1024 - sizeof(struct hv_get_perf_counter_info_params)) |
| 132 | |
| 133 | static unsigned long single_gpci_request(u32 req, u32 starting_index, |
| 134 | u16 secondary_index, u8 version_in, u32 offset, u8 length, |
| 135 | u64 *value) |
| 136 | { |
| 137 | unsigned long ret; |
| 138 | size_t i; |
| 139 | u64 count; |
| 140 | |
| 141 | struct { |
| 142 | struct hv_get_perf_counter_info_params params; |
| 143 | uint8_t bytes[GPCI_MAX_DATA_BYTES]; |
| 144 | } __packed __aligned(sizeof(uint64_t)) arg = { |
| 145 | .params = { |
| 146 | .counter_request = cpu_to_be32(req), |
| 147 | .starting_index = cpu_to_be32(starting_index), |
| 148 | .secondary_index = cpu_to_be16(secondary_index), |
| 149 | .counter_info_version_in = version_in, |
| 150 | } |
| 151 | }; |
| 152 | |
| 153 | ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO, |
| 154 | virt_to_phys(&arg), sizeof(arg)); |
| 155 | if (ret) { |
| 156 | pr_devel("hcall failed: 0x%lx\n", ret); |
| 157 | return ret; |
| 158 | } |
| 159 | |
| 160 | /* |
| 161 | * we verify offset and length are within the zeroed buffer at event |
| 162 | * init. |
| 163 | */ |
| 164 | count = 0; |
| 165 | for (i = offset; i < offset + length; i++) |
| 166 | count |= arg.bytes[i] << (i - offset); |
| 167 | |
| 168 | *value = count; |
| 169 | return ret; |
| 170 | } |
| 171 | |
| 172 | static u64 h_gpci_get_value(struct perf_event *event) |
| 173 | { |
| 174 | u64 count; |
| 175 | unsigned long ret = single_gpci_request(event_get_request(event), |
| 176 | event_get_starting_index(event), |
| 177 | event_get_secondary_index(event), |
| 178 | event_get_counter_info_version(event), |
| 179 | event_get_offset(event), |
| 180 | event_get_length(event), |
| 181 | &count); |
| 182 | if (ret) |
| 183 | return 0; |
| 184 | return count; |
| 185 | } |
| 186 | |
| 187 | static void h_gpci_event_update(struct perf_event *event) |
| 188 | { |
| 189 | s64 prev; |
| 190 | u64 now = h_gpci_get_value(event); |
| 191 | prev = local64_xchg(&event->hw.prev_count, now); |
| 192 | local64_add(now - prev, &event->count); |
| 193 | } |
| 194 | |
| 195 | static void h_gpci_event_start(struct perf_event *event, int flags) |
| 196 | { |
| 197 | local64_set(&event->hw.prev_count, h_gpci_get_value(event)); |
| 198 | } |
| 199 | |
| 200 | static void h_gpci_event_stop(struct perf_event *event, int flags) |
| 201 | { |
| 202 | h_gpci_event_update(event); |
| 203 | } |
| 204 | |
| 205 | static int h_gpci_event_add(struct perf_event *event, int flags) |
| 206 | { |
| 207 | if (flags & PERF_EF_START) |
| 208 | h_gpci_event_start(event, flags); |
| 209 | |
| 210 | return 0; |
| 211 | } |
| 212 | |
| 213 | static int h_gpci_event_init(struct perf_event *event) |
| 214 | { |
| 215 | u64 count; |
| 216 | u8 length; |
| 217 | |
| 218 | /* Not our event */ |
| 219 | if (event->attr.type != event->pmu->type) |
| 220 | return -ENOENT; |
| 221 | |
| 222 | /* config2 is unused */ |
| 223 | if (event->attr.config2) { |
| 224 | pr_devel("config2 set when reserved\n"); |
| 225 | return -EINVAL; |
| 226 | } |
| 227 | |
| 228 | /* unsupported modes and filters */ |
| 229 | if (event->attr.exclude_user || |
| 230 | event->attr.exclude_kernel || |
| 231 | event->attr.exclude_hv || |
| 232 | event->attr.exclude_idle || |
| 233 | event->attr.exclude_host || |
Vince Weaver | cc56d67 | 2014-06-19 14:40:09 -0400 | [diff] [blame] | 234 | event->attr.exclude_guest) |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 235 | return -EINVAL; |
| 236 | |
| 237 | /* no branch sampling */ |
| 238 | if (has_branch_stack(event)) |
| 239 | return -EOPNOTSUPP; |
| 240 | |
| 241 | length = event_get_length(event); |
| 242 | if (length < 1 || length > 8) { |
| 243 | pr_devel("length invalid\n"); |
| 244 | return -EINVAL; |
| 245 | } |
| 246 | |
| 247 | /* last byte within the buffer? */ |
| 248 | if ((event_get_offset(event) + length) > GPCI_MAX_DATA_BYTES) { |
| 249 | pr_devel("request outside of buffer: %zu > %zu\n", |
| 250 | (size_t)event_get_offset(event) + length, |
| 251 | GPCI_MAX_DATA_BYTES); |
| 252 | return -EINVAL; |
| 253 | } |
| 254 | |
| 255 | /* check if the request works... */ |
| 256 | if (single_gpci_request(event_get_request(event), |
| 257 | event_get_starting_index(event), |
| 258 | event_get_secondary_index(event), |
| 259 | event_get_counter_info_version(event), |
| 260 | event_get_offset(event), |
| 261 | length, |
| 262 | &count)) { |
| 263 | pr_devel("gpci hcall failed\n"); |
| 264 | return -EINVAL; |
| 265 | } |
| 266 | |
| 267 | return 0; |
| 268 | } |
| 269 | |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 270 | static struct pmu h_gpci_pmu = { |
| 271 | .task_ctx_nr = perf_invalid_context, |
| 272 | |
| 273 | .name = "hv_gpci", |
| 274 | .attr_groups = attr_groups, |
| 275 | .event_init = h_gpci_event_init, |
| 276 | .add = h_gpci_event_add, |
| 277 | .del = h_gpci_event_stop, |
| 278 | .start = h_gpci_event_start, |
| 279 | .stop = h_gpci_event_stop, |
| 280 | .read = h_gpci_event_update, |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 281 | }; |
| 282 | |
| 283 | static int hv_gpci_init(void) |
| 284 | { |
| 285 | int r; |
| 286 | unsigned long hret; |
| 287 | struct hv_perf_caps caps; |
| 288 | |
Cody P Schafer | 9e9f601 | 2015-01-30 13:46:01 -0800 | [diff] [blame] | 289 | hv_gpci_assert_offsets_correct(); |
| 290 | |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 291 | if (!firmware_has_feature(FW_FEATURE_LPAR)) { |
Cody P Schafer | 0a8cf9e | 2014-04-15 10:10:51 -0700 | [diff] [blame] | 292 | pr_debug("not a virtualized system, not enabling\n"); |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 293 | return -ENODEV; |
| 294 | } |
| 295 | |
| 296 | hret = hv_perf_caps_get(&caps); |
| 297 | if (hret) { |
Cody P Schafer | 0a8cf9e | 2014-04-15 10:10:51 -0700 | [diff] [blame] | 298 | pr_debug("could not obtain capabilities, not enabling, rc=%ld\n", |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 299 | hret); |
| 300 | return -ENODEV; |
| 301 | } |
| 302 | |
Vince Weaver | cc56d67 | 2014-06-19 14:40:09 -0400 | [diff] [blame] | 303 | /* sampling not supported */ |
| 304 | h_gpci_pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT; |
| 305 | |
Cody P Schafer | 220a0c6 | 2014-03-14 16:00:41 +1100 | [diff] [blame] | 306 | r = perf_pmu_register(&h_gpci_pmu, h_gpci_pmu.name, -1); |
| 307 | if (r) |
| 308 | return r; |
| 309 | |
| 310 | return 0; |
| 311 | } |
| 312 | |
| 313 | device_initcall(hv_gpci_init); |