arch/powerpc/perf/hv-gpci.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Hypervisor supplied "gpci" ("get performance counter info") performance
   4  * counter support
   5  *
   6  * Author: Cody P Schafer <cody@linux.vnet.ibm.com>
   7  * Copyright 2014 IBM Corporation.
   8  */
   9
  10 #define pr_fmt(fmt) "hv-gpci: " fmt
  11
  12 #include <linux/init.h>
  13 #include <linux/perf_event.h>
  14 #include <asm/firmware.h>
  15 #include <asm/hvcall.h>
  16 #include <asm/io.h>
  17
  18 #include "hv-gpci.h"
  19 #include "hv-common.h"
  20
  21 /*
  22  * Example usage:
  23  *  perf stat -e 'hv_gpci/counter_info_version=3,offset=0,length=8,
  24  *                secondary_index=0,starting_index=0xffffffff,request=0x10/' ...
  25  */
  26
  27 /* u32 */
  28 EVENT_DEFINE_RANGE_FORMAT(request, config, 0, 31);
  29 /* u32 */
  30 /*
  31  * Note that starting_index, phys_processor_idx, sibling_part_id,
  32  * hw_chip_id, partition_id all refer to the same bit range. They
  33  * are basically aliases for the starting_index. The specific alias
  34  * used depends on the event. See REQUEST_IDX_KIND in hv-gpci-requests.h
  35  */
  36 EVENT_DEFINE_RANGE_FORMAT(starting_index, config, 32, 63);
  37 EVENT_DEFINE_RANGE_FORMAT_LITE(phys_processor_idx, config, 32, 63);
  38 EVENT_DEFINE_RANGE_FORMAT_LITE(sibling_part_id, config, 32, 63);
  39 EVENT_DEFINE_RANGE_FORMAT_LITE(hw_chip_id, config, 32, 63);
  40 EVENT_DEFINE_RANGE_FORMAT_LITE(partition_id, config, 32, 63);
  41
  42 /* u16 */
  43 EVENT_DEFINE_RANGE_FORMAT(secondary_index, config1, 0, 15);
  44 /* u8 */
  45 EVENT_DEFINE_RANGE_FORMAT(counter_info_version, config1, 16, 23);
  46 /* u8, bytes of data (1-8) */
  47 EVENT_DEFINE_RANGE_FORMAT(length, config1, 24, 31);
  48 /* u32, byte offset */
  49 EVENT_DEFINE_RANGE_FORMAT(offset, config1, 32, 63);
  50
  51 static cpumask_t hv_gpci_cpumask;
  52
  53 static struct attribute *format_attrs[] = {
  54         &format_attr_request.attr,
  55         &format_attr_starting_index.attr,
  56         &format_attr_phys_processor_idx.attr,
  57         &format_attr_sibling_part_id.attr,
  58         &format_attr_hw_chip_id.attr,
  59         &format_attr_partition_id.attr,
  60         &format_attr_secondary_index.attr,
  61         &format_attr_counter_info_version.attr,
  62
  63         &format_attr_offset.attr,
  64         &format_attr_length.attr,
  65         NULL,
  66 };
  67
  68 static const struct attribute_group format_group = {
  69         .name = "format",
  70         .attrs = format_attrs,
  71 };
  72
  73 static struct attribute_group event_group = {
  74         .name  = "events",
  75         /* .attrs is set in init */
  76 };
  77
  78 #define HV_CAPS_ATTR(_name, _format)                            \
  79 static ssize_t _name##_show(struct device *dev,                 \
  80                             struct device_attribute *attr,      \
  81                             char *page)                         \
  82 {                                                               \
  83         struct hv_perf_caps caps;                               \
  84         unsigned long hret = hv_perf_caps_get(&caps);           \
  85         if (hret)                                               \
  86                 return -EIO;                                    \
  87                                                                 \
  88         return sprintf(page, _format, caps._name);              \
  89 }                                                               \
  90 static struct device_attribute hv_caps_attr_##_name = __ATTR_RO(_name)
  91
  92 static ssize_t kernel_version_show(struct device *dev,
  93                                    struct device_attribute *attr,
  94                                    char *page)
  95 {
  96         return sprintf(page, "0x%x\n", COUNTER_INFO_VERSION_CURRENT);
  97 }
  98
  99 static ssize_t cpumask_show(struct device *dev,
 100                             struct device_attribute *attr, char *buf)
 101 {
 102         return cpumap_print_to_pagebuf(true, buf, &hv_gpci_cpumask);
 103 }
 104
 105 /* Interface attribute array index to store system information */
 106 #define INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR   6
 107 #define INTERFACE_PROCESSOR_CONFIG_ATTR         7
 108 #define INTERFACE_AFFINITY_DOMAIN_VIA_VP_ATTR   8
 109 #define INTERFACE_AFFINITY_DOMAIN_VIA_DOM_ATTR  9
 110 #define INTERFACE_AFFINITY_DOMAIN_VIA_PAR_ATTR  10
 111 #define INTERFACE_NULL_ATTR                     11
 112
 113 /* Counter request value to retrieve system information */
 114 enum {
 115         PROCESSOR_BUS_TOPOLOGY,
 116         PROCESSOR_CONFIG,
 117         AFFINITY_DOMAIN_VIA_VP, /* affinity domain via virtual processor */
 118         AFFINITY_DOMAIN_VIA_DOM, /* affinity domain via domain */
 119         AFFINITY_DOMAIN_VIA_PAR, /* affinity domain via partition */
 120 };
 121
 122 static int sysinfo_counter_request[] = {
 123         [PROCESSOR_BUS_TOPOLOGY] = 0xD0,
 124         [PROCESSOR_CONFIG] = 0x90,
 125         [AFFINITY_DOMAIN_VIA_VP] = 0xA0,
 126         [AFFINITY_DOMAIN_VIA_DOM] = 0xB0,
 127         [AFFINITY_DOMAIN_VIA_PAR] = 0xB1,
 128 };
 129
 130 static DEFINE_PER_CPU(char, hv_gpci_reqb[HGPCI_REQ_BUFFER_SIZE]) __aligned(sizeof(uint64_t));
 131
 132 static unsigned long systeminfo_gpci_request(u32 req, u32 starting_index,
 133                         u16 secondary_index, char *buf,
 134                         size_t *n, struct hv_gpci_request_buffer *arg)
 135 {
 136         unsigned long ret;
 137         size_t i, j;
 138
 139         arg->params.counter_request = cpu_to_be32(req);
 140         arg->params.starting_index = cpu_to_be32(starting_index);
 141         arg->params.secondary_index = cpu_to_be16(secondary_index);
 142
 143         ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 144                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 145
 146         /*
 147          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL',
 148          * which means that the current buffer size cannot accommodate
 149          * all the information and a partial buffer returned.
 150          * hcall fails incase of ret value other than H_SUCCESS or H_PARAMETER.
 151          *
 152          * ret value as H_AUTHORITY implies that partition is not permitted to retrieve
 153          * performance information, and required to set
 154          * "Enable Performance Information Collection" option.
 155          */
 156         if (ret == H_AUTHORITY)
 157                 return -EPERM;
 158
 159         /*
 160          * hcall can fail with other possible ret value like H_PRIVILEGE/H_HARDWARE
 161          * because of invalid buffer-length/address or due to some hardware
 162          * error.
 163          */
 164         if (ret && (ret != H_PARAMETER))
 165                 return -EIO;
 166
 167         /*
 168          * hcall H_GET_PERF_COUNTER_INFO populates the 'returned_values'
 169          * to show the total number of counter_value array elements
 170          * returned via hcall.
 171          * hcall also populates 'cv_element_size' corresponds to individual
 172          * counter_value array element size. Below loop go through all
 173          * counter_value array elements as per their size and add it to
 174          * the output buffer.
 175          */
 176         for (i = 0; i < be16_to_cpu(arg->params.returned_values); i++) {
 177                 j = i * be16_to_cpu(arg->params.cv_element_size);
 178
 179                 for (; j < (i + 1) * be16_to_cpu(arg->params.cv_element_size); j++)
 180                         *n += sprintf(buf + *n,  "%02x", (u8)arg->bytes[j]);
 181                 *n += sprintf(buf + *n,  "\n");
 182         }
 183
 184         if (*n >= PAGE_SIZE) {
 185                 pr_info("System information exceeds PAGE_SIZE\n");
 186                 return -EFBIG;
 187         }
 188
 189         return ret;
 190 }
 191
 192 static ssize_t processor_bus_topology_show(struct device *dev, struct device_attribute *attr,
 193                                 char *buf)
 194 {
 195         struct hv_gpci_request_buffer *arg;
 196         unsigned long ret;
 197         size_t n = 0;
 198
 199         arg = (void *)get_cpu_var(hv_gpci_reqb);
 200         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 201
 202         /*
 203          * Pass the counter request value 0xD0 corresponds to request
 204          * type 'Processor_bus_topology', to retrieve
 205          * the system topology information.
 206          * starting_index value implies the starting hardware
 207          * chip id.
 208          */
 209         ret = systeminfo_gpci_request(sysinfo_counter_request[PROCESSOR_BUS_TOPOLOGY],
 210                         0, 0, buf, &n, arg);
 211
 212         if (!ret)
 213                 return n;
 214
 215         if (ret != H_PARAMETER)
 216                 goto out;
 217
 218         /*
 219          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL', which
 220          * implies that buffer can't accommodate all information, and a partial buffer
 221          * returned. To handle that, we need to make subsequent requests
 222          * with next starting index to retrieve additional (missing) data.
 223          * Below loop do subsequent hcalls with next starting index and add it
 224          * to buffer util we get all the information.
 225          */
 226         while (ret == H_PARAMETER) {
 227                 int returned_values = be16_to_cpu(arg->params.returned_values);
 228                 int elementsize = be16_to_cpu(arg->params.cv_element_size);
 229                 int last_element = (returned_values - 1) * elementsize;
 230
 231                 /*
 232                  * Since the starting index value is part of counter_value
 233                  * buffer elements, use the starting index value in the last
 234                  * element and add 1 to make subsequent hcalls.
 235                  */
 236                 u32 starting_index = arg->bytes[last_element + 3] +
 237                                 (arg->bytes[last_element + 2] << 8) +
 238                                 (arg->bytes[last_element + 1] << 16) +
 239                                 (arg->bytes[last_element] << 24) + 1;
 240
 241                 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 242
 243                 ret = systeminfo_gpci_request(sysinfo_counter_request[PROCESSOR_BUS_TOPOLOGY],
 244                                 starting_index, 0, buf, &n, arg);
 245
 246                 if (!ret)
 247                         return n;
 248
 249                 if (ret != H_PARAMETER)
 250                         goto out;
 251         }
 252
 253         return n;
 254
 255 out:
 256         put_cpu_var(hv_gpci_reqb);
 257         return ret;
 258 }
 259
 260 static ssize_t processor_config_show(struct device *dev, struct device_attribute *attr,
 261                                         char *buf)
 262 {
 263         struct hv_gpci_request_buffer *arg;
 264         unsigned long ret;
 265         size_t n = 0;
 266
 267         arg = (void *)get_cpu_var(hv_gpci_reqb);
 268         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 269
 270         /*
 271          * Pass the counter request value 0x90 corresponds to request
 272          * type 'Processor_config', to retrieve
 273          * the system processor information.
 274          * starting_index value implies the starting hardware
 275          * processor index.
 276          */
 277         ret = systeminfo_gpci_request(sysinfo_counter_request[PROCESSOR_CONFIG],
 278                         0, 0, buf, &n, arg);
 279
 280         if (!ret)
 281                 return n;
 282
 283         if (ret != H_PARAMETER)
 284                 goto out;
 285
 286         /*
 287          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL', which
 288          * implies that buffer can't accommodate all information, and a partial buffer
 289          * returned. To handle that, we need to take subsequent requests
 290          * with next starting index to retrieve additional (missing) data.
 291          * Below loop do subsequent hcalls with next starting index and add it
 292          * to buffer util we get all the information.
 293          */
 294         while (ret == H_PARAMETER) {
 295                 int returned_values = be16_to_cpu(arg->params.returned_values);
 296                 int elementsize = be16_to_cpu(arg->params.cv_element_size);
 297                 int last_element = (returned_values - 1) * elementsize;
 298
 299                 /*
 300                  * Since the starting index is part of counter_value
 301                  * buffer elements, use the starting index value in the last
 302                  * element and add 1 to subsequent hcalls.
 303                  */
 304                 u32 starting_index = arg->bytes[last_element + 3] +
 305                                 (arg->bytes[last_element + 2] << 8) +
 306                                 (arg->bytes[last_element + 1] << 16) +
 307                                 (arg->bytes[last_element] << 24) + 1;
 308
 309                 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 310
 311                 ret = systeminfo_gpci_request(sysinfo_counter_request[PROCESSOR_CONFIG],
 312                                 starting_index, 0, buf, &n, arg);
 313
 314                 if (!ret)
 315                         return n;
 316
 317                 if (ret != H_PARAMETER)
 318                         goto out;
 319         }
 320
 321         return n;
 322
 323 out:
 324         put_cpu_var(hv_gpci_reqb);
 325         return ret;
 326 }
 327
 328 static ssize_t affinity_domain_via_virtual_processor_show(struct device *dev,
 329                         struct device_attribute *attr, char *buf)
 330 {
 331         struct hv_gpci_request_buffer *arg;
 332         unsigned long ret;
 333         size_t n = 0;
 334
 335         arg = (void *)get_cpu_var(hv_gpci_reqb);
 336         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 337
 338         /*
 339          * Pass the counter request 0xA0 corresponds to request
 340          * type 'Affinity_domain_information_by_virutal_processor',
 341          * to retrieve the system affinity domain information.
 342          * starting_index value refers to the starting hardware
 343          * processor index.
 344          */
 345         ret = systeminfo_gpci_request(sysinfo_counter_request[AFFINITY_DOMAIN_VIA_VP],
 346                         0, 0, buf, &n, arg);
 347
 348         if (!ret)
 349                 return n;
 350
 351         if (ret != H_PARAMETER)
 352                 goto out;
 353
 354         /*
 355          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL', which
 356          * implies that buffer can't accommodate all information, and a partial buffer
 357          * returned. To handle that, we need to take subsequent requests
 358          * with next secondary index to retrieve additional (missing) data.
 359          * Below loop do subsequent hcalls with next secondary index and add it
 360          * to buffer util we get all the information.
 361          */
 362         while (ret == H_PARAMETER) {
 363                 int returned_values = be16_to_cpu(arg->params.returned_values);
 364                 int elementsize = be16_to_cpu(arg->params.cv_element_size);
 365                 int last_element = (returned_values - 1) * elementsize;
 366
 367                 /*
 368                  * Since the starting index and secondary index type is part of the
 369                  * counter_value buffer elements, use the starting index value in the
 370                  * last array element as subsequent starting index, and use secondary index
 371                  * value in the last array element plus 1 as subsequent secondary index.
 372                  * For counter request '0xA0', starting index points to partition id
 373                  * and secondary index points to corresponding virtual processor index.
 374                  */
 375                 u32 starting_index = arg->bytes[last_element + 1] + (arg->bytes[last_element] << 8);
 376                 u16 secondary_index = arg->bytes[last_element + 3] +
 377                                 (arg->bytes[last_element + 2] << 8) + 1;
 378
 379                 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 380
 381                 ret = systeminfo_gpci_request(sysinfo_counter_request[AFFINITY_DOMAIN_VIA_VP],
 382                                 starting_index, secondary_index, buf, &n, arg);
 383
 384                 if (!ret)
 385                         return n;
 386
 387                 if (ret != H_PARAMETER)
 388                         goto out;
 389         }
 390
 391         return n;
 392
 393 out:
 394         put_cpu_var(hv_gpci_reqb);
 395         return ret;
 396 }
 397
 398 static ssize_t affinity_domain_via_domain_show(struct device *dev, struct device_attribute *attr,
 399                                                 char *buf)
 400 {
 401         struct hv_gpci_request_buffer *arg;
 402         unsigned long ret;
 403         size_t n = 0;
 404
 405         arg = (void *)get_cpu_var(hv_gpci_reqb);
 406         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 407
 408         /*
 409          * Pass the counter request 0xB0 corresponds to request
 410          * type 'Affinity_domain_information_by_domain',
 411          * to retrieve the system affinity domain information.
 412          * starting_index value refers to the starting hardware
 413          * processor index.
 414          */
 415         ret = systeminfo_gpci_request(sysinfo_counter_request[AFFINITY_DOMAIN_VIA_DOM],
 416                         0, 0, buf, &n, arg);
 417
 418         if (!ret)
 419                 return n;
 420
 421         if (ret != H_PARAMETER)
 422                 goto out;
 423
 424         /*
 425          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL', which
 426          * implies that buffer can't accommodate all information, and a partial buffer
 427          * returned. To handle that, we need to take subsequent requests
 428          * with next starting index to retrieve additional (missing) data.
 429          * Below loop do subsequent hcalls with next starting index and add it
 430          * to buffer util we get all the information.
 431          */
 432         while (ret == H_PARAMETER) {
 433                 int returned_values = be16_to_cpu(arg->params.returned_values);
 434                 int elementsize = be16_to_cpu(arg->params.cv_element_size);
 435                 int last_element = (returned_values - 1) * elementsize;
 436
 437                 /*
 438                  * Since the starting index value is part of counter_value
 439                  * buffer elements, use the starting index value in the last
 440                  * element and add 1 to make subsequent hcalls.
 441                  */
 442                 u32 starting_index = arg->bytes[last_element + 1] +
 443                         (arg->bytes[last_element] << 8) + 1;
 444
 445                 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 446
 447                 ret = systeminfo_gpci_request(sysinfo_counter_request[AFFINITY_DOMAIN_VIA_DOM],
 448                                         starting_index, 0, buf, &n, arg);
 449
 450                 if (!ret)
 451                         return n;
 452
 453                 if (ret != H_PARAMETER)
 454                         goto out;
 455         }
 456
 457         return n;
 458
 459 out:
 460         put_cpu_var(hv_gpci_reqb);
 461         return ret;
 462 }
 463
 464 static void affinity_domain_via_partition_result_parse(int returned_values,
 465                         int element_size, char *buf, size_t *last_element,
 466                         size_t *n, struct hv_gpci_request_buffer *arg)
 467 {
 468         size_t i = 0, j = 0;
 469         size_t k, l, m;
 470         uint16_t total_affinity_domain_ele, size_of_each_affinity_domain_ele;
 471
 472         /*
 473          * hcall H_GET_PERF_COUNTER_INFO populates the 'returned_values'
 474          * to show the total number of counter_value array elements
 475          * returned via hcall.
 476          * Unlike other request types, the data structure returned by this
 477          * request is variable-size. For this counter request type,
 478          * hcall populates 'cv_element_size' corresponds to minimum size of
 479          * the structure returned i.e; the size of the structure with no domain
 480          * information. Below loop go through all counter_value array
 481          * to determine the number and size of each domain array element and
 482          * add it to the output buffer.
 483          */
 484         while (i < returned_values) {
 485                 k = j;
 486                 for (; k < j + element_size; k++)
 487                         *n += sprintf(buf + *n,  "%02x", (u8)arg->bytes[k]);
 488                 *n += sprintf(buf + *n,  "\n");
 489
 490                 total_affinity_domain_ele = (u8)arg->bytes[k - 2] << 8 | (u8)arg->bytes[k - 3];
 491                 size_of_each_affinity_domain_ele = (u8)arg->bytes[k] << 8 | (u8)arg->bytes[k - 1];
 492
 493                 for (l = 0; l < total_affinity_domain_ele; l++) {
 494                         for (m = 0; m < size_of_each_affinity_domain_ele; m++) {
 495                                 *n += sprintf(buf + *n,  "%02x", (u8)arg->bytes[k]);
 496                                 k++;
 497                         }
 498                         *n += sprintf(buf + *n,  "\n");
 499                 }
 500
 501                 *n += sprintf(buf + *n,  "\n");
 502                 i++;
 503                 j = k;
 504         }
 505
 506         *last_element = k;
 507 }
 508
 509 static ssize_t affinity_domain_via_partition_show(struct device *dev, struct device_attribute *attr,
 510                                                         char *buf)
 511 {
 512         struct hv_gpci_request_buffer *arg;
 513         unsigned long ret;
 514         size_t n = 0;
 515         size_t last_element = 0;
 516         u32 starting_index;
 517
 518         arg = (void *)get_cpu_var(hv_gpci_reqb);
 519         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 520
 521         /*
 522          * Pass the counter request value 0xB1 corresponds to counter request
 523          * type 'Affinity_domain_information_by_partition',
 524          * to retrieve the system affinity domain by partition information.
 525          * starting_index value refers to the starting hardware
 526          * processor index.
 527          */
 528         arg->params.counter_request = cpu_to_be32(sysinfo_counter_request[AFFINITY_DOMAIN_VIA_PAR]);
 529         arg->params.starting_index = cpu_to_be32(0);
 530
 531         ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 532                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 533
 534         if (!ret)
 535                 goto parse_result;
 536
 537         if (ret && (ret != H_PARAMETER))
 538                 goto out;
 539
 540         /*
 541          * ret value as 'H_PARAMETER' implies that the current buffer size
 542          * can't accommodate all the information, and a partial buffer
 543          * returned. To handle that, we need to make subsequent requests
 544          * with next starting index to retrieve additional (missing) data.
 545          * Below loop do subsequent hcalls with next starting index and add it
 546          * to buffer util we get all the information.
 547          */
 548         while (ret == H_PARAMETER) {
 549                 affinity_domain_via_partition_result_parse(
 550                         be16_to_cpu(arg->params.returned_values) - 1,
 551                         be16_to_cpu(arg->params.cv_element_size), buf,
 552                         &last_element, &n, arg);
 553
 554                 if (n >= PAGE_SIZE) {
 555                         put_cpu_var(hv_gpci_reqb);
 556                         pr_debug("System information exceeds PAGE_SIZE\n");
 557                         return -EFBIG;
 558                 }
 559
 560                 /*
 561                  * Since the starting index value is part of counter_value
 562                  * buffer elements, use the starting_index value in the last
 563                  * element and add 1 to make subsequent hcalls.
 564                  */
 565                 starting_index = (u8)arg->bytes[last_element] << 8 |
 566                                 (u8)arg->bytes[last_element + 1];
 567
 568                 memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 569                 arg->params.counter_request = cpu_to_be32(
 570                                 sysinfo_counter_request[AFFINITY_DOMAIN_VIA_PAR]);
 571                 arg->params.starting_index = cpu_to_be32(starting_index);
 572
 573                 ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 574                                 virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 575
 576                 if (ret && (ret != H_PARAMETER))
 577                         goto out;
 578         }
 579
 580 parse_result:
 581         affinity_domain_via_partition_result_parse(
 582                 be16_to_cpu(arg->params.returned_values),
 583                 be16_to_cpu(arg->params.cv_element_size),
 584                 buf, &last_element, &n, arg);
 585
 586         put_cpu_var(hv_gpci_reqb);
 587         return n;
 588
 589 out:
 590         put_cpu_var(hv_gpci_reqb);
 591
 592         /*
 593          * ret value as 'H_PARAMETER' corresponds to 'GEN_BUF_TOO_SMALL',
 594          * which means that the current buffer size cannot accommodate
 595          * all the information and a partial buffer returned.
 596          * hcall fails incase of ret value other than H_SUCCESS or H_PARAMETER.
 597          *
 598          * ret value as H_AUTHORITY implies that partition is not permitted to retrieve
 599          * performance information, and required to set
 600          * "Enable Performance Information Collection" option.
 601          */
 602         if (ret == H_AUTHORITY)
 603                 return -EPERM;
 604
 605         /*
 606          * hcall can fail with other possible ret value like H_PRIVILEGE/H_HARDWARE
 607          * because of invalid buffer-length/address or due to some hardware
 608          * error.
 609          */
 610         return -EIO;
 611 }
 612
 613 static DEVICE_ATTR_RO(kernel_version);
 614 static DEVICE_ATTR_RO(cpumask);
 615
 616 HV_CAPS_ATTR(version, "0x%x\n");
 617 HV_CAPS_ATTR(ga, "%d\n");
 618 HV_CAPS_ATTR(expanded, "%d\n");
 619 HV_CAPS_ATTR(lab, "%d\n");
 620 HV_CAPS_ATTR(collect_privileged, "%d\n");
 621
 622 static struct attribute *interface_attrs[] = {
 623         &dev_attr_kernel_version.attr,
 624         &hv_caps_attr_version.attr,
 625         &hv_caps_attr_ga.attr,
 626         &hv_caps_attr_expanded.attr,
 627         &hv_caps_attr_lab.attr,
 628         &hv_caps_attr_collect_privileged.attr,
 629         /*
 630          * This NULL is a placeholder for the processor_bus_topology
 631          * attribute, set in init function if applicable.
 632          */
 633         NULL,
 634         /*
 635          * This NULL is a placeholder for the processor_config
 636          * attribute, set in init function if applicable.
 637          */
 638         NULL,
 639         /*
 640          * This NULL is a placeholder for the affinity_domain_via_virtual_processor
 641          * attribute, set in init function if applicable.
 642          */
 643         NULL,
 644         /*
 645          * This NULL is a placeholder for the affinity_domain_via_domain
 646          * attribute, set in init function if applicable.
 647          */
 648         NULL,
 649         /*
 650          * This NULL is a placeholder for the affinity_domain_via_partition
 651          * attribute, set in init function if applicable.
 652          */
 653         NULL,
 654         NULL,
 655 };
 656
 657 static struct attribute *cpumask_attrs[] = {
 658         &dev_attr_cpumask.attr,
 659         NULL,
 660 };
 661
 662 static const struct attribute_group cpumask_attr_group = {
 663         .attrs = cpumask_attrs,
 664 };
 665
 666 static const struct attribute_group interface_group = {
 667         .name = "interface",
 668         .attrs = interface_attrs,
 669 };
 670
 671 static const struct attribute_group *attr_groups[] = {
 672         &format_group,
 673         &event_group,
 674         &interface_group,
 675         &cpumask_attr_group,
 676         NULL,
 677 };
 678
 679 static unsigned long single_gpci_request(u32 req, u32 starting_index,
 680                 u16 secondary_index, u8 version_in, u32 offset, u8 length,
 681                 u64 *value)
 682 {
 683         unsigned long ret;
 684         size_t i;
 685         u64 count;
 686         struct hv_gpci_request_buffer *arg;
 687
 688         arg = (void *)get_cpu_var(hv_gpci_reqb);
 689         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 690
 691         arg->params.counter_request = cpu_to_be32(req);
 692         arg->params.starting_index = cpu_to_be32(starting_index);
 693         arg->params.secondary_index = cpu_to_be16(secondary_index);
 694         arg->params.counter_info_version_in = version_in;
 695
 696         ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 697                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 698         if (ret) {
 699                 pr_devel("hcall failed: 0x%lx\n", ret);
 700                 goto out;
 701         }
 702
 703         /*
 704          * we verify offset and length are within the zeroed buffer at event
 705          * init.
 706          */
 707         count = 0;
 708         for (i = offset; i < offset + length; i++)
 709                 count |= (u64)(arg->bytes[i]) << ((length - 1 - (i - offset)) * 8);
 710
 711         *value = count;
 712 out:
 713         put_cpu_var(hv_gpci_reqb);
 714         return ret;
 715 }
 716
 717 static u64 h_gpci_get_value(struct perf_event *event)
 718 {
 719         u64 count;
 720         unsigned long ret = single_gpci_request(event_get_request(event),
 721                                         event_get_starting_index(event),
 722                                         event_get_secondary_index(event),
 723                                         event_get_counter_info_version(event),
 724                                         event_get_offset(event),
 725                                         event_get_length(event),
 726                                         &count);
 727         if (ret)
 728                 return 0;
 729         return count;
 730 }
 731
 732 static void h_gpci_event_update(struct perf_event *event)
 733 {
 734         s64 prev;
 735         u64 now = h_gpci_get_value(event);
 736         prev = local64_xchg(&event->hw.prev_count, now);
 737         local64_add(now - prev, &event->count);
 738 }
 739
 740 static void h_gpci_event_start(struct perf_event *event, int flags)
 741 {
 742         local64_set(&event->hw.prev_count, h_gpci_get_value(event));
 743 }
 744
 745 static void h_gpci_event_stop(struct perf_event *event, int flags)
 746 {
 747         h_gpci_event_update(event);
 748 }
 749
 750 static int h_gpci_event_add(struct perf_event *event, int flags)
 751 {
 752         if (flags & PERF_EF_START)
 753                 h_gpci_event_start(event, flags);
 754
 755         return 0;
 756 }
 757
 758 static int h_gpci_event_init(struct perf_event *event)
 759 {
 760         u64 count;
 761         u8 length;
 762
 763         /* Not our event */
 764         if (event->attr.type != event->pmu->type)
 765                 return -ENOENT;
 766
 767         /* config2 is unused */
 768         if (event->attr.config2) {
 769                 pr_devel("config2 set when reserved\n");
 770                 return -EINVAL;
 771         }
 772
 773         /* no branch sampling */
 774         if (has_branch_stack(event))
 775                 return -EOPNOTSUPP;
 776
 777         length = event_get_length(event);
 778         if (length < 1 || length > 8) {
 779                 pr_devel("length invalid\n");
 780                 return -EINVAL;
 781         }
 782
 783         /* last byte within the buffer? */
 784         if ((event_get_offset(event) + length) > HGPCI_MAX_DATA_BYTES) {
 785                 pr_devel("request outside of buffer: %zu > %zu\n",
 786                                 (size_t)event_get_offset(event) + length,
 787                                 HGPCI_MAX_DATA_BYTES);
 788                 return -EINVAL;
 789         }
 790
 791         /* check if the request works... */
 792         if (single_gpci_request(event_get_request(event),
 793                                 event_get_starting_index(event),
 794                                 event_get_secondary_index(event),
 795                                 event_get_counter_info_version(event),
 796                                 event_get_offset(event),
 797                                 length,
 798                                 &count)) {
 799                 pr_devel("gpci hcall failed\n");
 800                 return -EINVAL;
 801         }
 802
 803         return 0;
 804 }
 805
 806 static struct pmu h_gpci_pmu = {
 807         .task_ctx_nr = perf_invalid_context,
 808
 809         .name = "hv_gpci",
 810         .attr_groups = attr_groups,
 811         .event_init  = h_gpci_event_init,
 812         .add         = h_gpci_event_add,
 813         .del         = h_gpci_event_stop,
 814         .start       = h_gpci_event_start,
 815         .stop        = h_gpci_event_stop,
 816         .read        = h_gpci_event_update,
 817         .capabilities = PERF_PMU_CAP_NO_EXCLUDE,
 818 };
 819
 820 static int ppc_hv_gpci_cpu_online(unsigned int cpu)
 821 {
 822         if (cpumask_empty(&hv_gpci_cpumask))
 823                 cpumask_set_cpu(cpu, &hv_gpci_cpumask);
 824
 825         return 0;
 826 }
 827
 828 static int ppc_hv_gpci_cpu_offline(unsigned int cpu)
 829 {
 830         int target;
 831
 832         /* Check if exiting cpu is used for collecting gpci events */
 833         if (!cpumask_test_and_clear_cpu(cpu, &hv_gpci_cpumask))
 834                 return 0;
 835
 836         /* Find a new cpu to collect gpci events */
 837         target = cpumask_last(cpu_active_mask);
 838
 839         if (target < 0 || target >= nr_cpu_ids) {
 840                 pr_err("hv_gpci: CPU hotplug init failed\n");
 841                 return -1;
 842         }
 843
 844         /* Migrate gpci events to the new target */
 845         cpumask_set_cpu(target, &hv_gpci_cpumask);
 846         perf_pmu_migrate_context(&h_gpci_pmu, cpu, target);
 847
 848         return 0;
 849 }
 850
 851 static int hv_gpci_cpu_hotplug_init(void)
 852 {
 853         return cpuhp_setup_state(CPUHP_AP_PERF_POWERPC_HV_GPCI_ONLINE,
 854                           "perf/powerpc/hv_gcpi:online",
 855                           ppc_hv_gpci_cpu_online,
 856                           ppc_hv_gpci_cpu_offline);
 857 }
 858
 859 static struct device_attribute *sysinfo_device_attr_create(int
 860                 sysinfo_interface_group_index, u32 req)
 861 {
 862         struct device_attribute *attr = NULL;
 863         unsigned long ret;
 864         struct hv_gpci_request_buffer *arg;
 865
 866         if (sysinfo_interface_group_index < INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR ||
 867                         sysinfo_interface_group_index >= INTERFACE_NULL_ATTR) {
 868                 pr_info("Wrong interface group index for system information\n");
 869                 return NULL;
 870         }
 871
 872         /* Check for given counter request value support */
 873         arg = (void *)get_cpu_var(hv_gpci_reqb);
 874         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 875
 876         arg->params.counter_request = cpu_to_be32(req);
 877
 878         ret = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
 879                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
 880
 881         put_cpu_var(hv_gpci_reqb);
 882
 883         /*
 884          * Add given counter request value attribute in the interface_attrs
 885          * attribute array, only for valid return types.
 886          */
 887         if (!ret || ret == H_AUTHORITY || ret == H_PARAMETER) {
 888                 attr = kzalloc(sizeof(*attr), GFP_KERNEL);
 889                 if (!attr)
 890                         return NULL;
 891
 892                 sysfs_attr_init(&attr->attr);
 893                 attr->attr.mode = 0444;
 894
 895                 switch (sysinfo_interface_group_index) {
 896                 case INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR:
 897                         attr->attr.name = "processor_bus_topology";
 898                         attr->show = processor_bus_topology_show;
 899                 break;
 900                 case INTERFACE_PROCESSOR_CONFIG_ATTR:
 901                         attr->attr.name = "processor_config";
 902                         attr->show = processor_config_show;
 903                 break;
 904                 case INTERFACE_AFFINITY_DOMAIN_VIA_VP_ATTR:
 905                         attr->attr.name = "affinity_domain_via_virtual_processor";
 906                         attr->show = affinity_domain_via_virtual_processor_show;
 907                 break;
 908                 case INTERFACE_AFFINITY_DOMAIN_VIA_DOM_ATTR:
 909                         attr->attr.name = "affinity_domain_via_domain";
 910                         attr->show = affinity_domain_via_domain_show;
 911                 break;
 912                 case INTERFACE_AFFINITY_DOMAIN_VIA_PAR_ATTR:
 913                         attr->attr.name = "affinity_domain_via_partition";
 914                         attr->show = affinity_domain_via_partition_show;
 915                 break;
 916                 }
 917         } else
 918                 pr_devel("hcall failed, with error: 0x%lx\n", ret);
 919
 920         return attr;
 921 }
 922
 923 static void add_sysinfo_interface_files(void)
 924 {
 925         int sysfs_count;
 926         struct device_attribute *attr[INTERFACE_NULL_ATTR - INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR];
 927         int i;
 928
 929         sysfs_count = INTERFACE_NULL_ATTR - INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR;
 930
 931         /* Get device attribute for a given counter request value */
 932         for (i = 0; i < sysfs_count; i++) {
 933                 attr[i] = sysinfo_device_attr_create(i + INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR,
 934                                 sysinfo_counter_request[i]);
 935
 936                 if (!attr[i])
 937                         goto out;
 938         }
 939
 940         /* Add sysinfo interface attributes in the interface_attrs attribute array */
 941         for (i = 0; i < sysfs_count; i++)
 942                 interface_attrs[i + INTERFACE_PROCESSOR_BUS_TOPOLOGY_ATTR] = &attr[i]->attr;
 943
 944         return;
 945
 946 out:
 947         /*
 948          * The sysinfo interface attributes will be added, only if hcall passed for
 949          * all the counter request values. Free the device attribute array incase
 950          * of any hcall failure.
 951          */
 952         if (i > 0) {
 953                 while (i >= 0) {
 954                         kfree(attr[i]);
 955                         i--;
 956                 }
 957         }
 958 }
 959
 960 static int hv_gpci_init(void)
 961 {
 962         int r;
 963         unsigned long hret;
 964         struct hv_perf_caps caps;
 965         struct hv_gpci_request_buffer *arg;
 966
 967         hv_gpci_assert_offsets_correct();
 968
 969         if (!firmware_has_feature(FW_FEATURE_LPAR)) {
 970                 pr_debug("not a virtualized system, not enabling\n");
 971                 return -ENODEV;
 972         }
 973
 974         hret = hv_perf_caps_get(&caps);
 975         if (hret) {
 976                 pr_debug("could not obtain capabilities, not enabling, rc=%ld\n",
 977                                 hret);
 978                 return -ENODEV;
 979         }
 980
 981         /* init cpuhotplug */
 982         r = hv_gpci_cpu_hotplug_init();
 983         if (r)
 984                 return r;
 985
 986         /* sampling not supported */
 987         h_gpci_pmu.capabilities |= PERF_PMU_CAP_NO_INTERRUPT;
 988
 989         arg = (void *)get_cpu_var(hv_gpci_reqb);
 990         memset(arg, 0, HGPCI_REQ_BUFFER_SIZE);
 991
 992         /*
 993          * hcall H_GET_PERF_COUNTER_INFO populates the output
 994          * counter_info_version value based on the system hypervisor.
 995          * Pass the counter request 0x10 corresponds to request type
 996          * 'Dispatch_timebase_by_processor', to get the supported
 997          * counter_info_version.
 998          */
 999         arg->params.counter_request = cpu_to_be32(0x10);
1000
1001         r = plpar_hcall_norets(H_GET_PERF_COUNTER_INFO,
1002                         virt_to_phys(arg), HGPCI_REQ_BUFFER_SIZE);
1003         if (r) {
1004                 pr_devel("hcall failed, can't get supported counter_info_version: 0x%x\n", r);
1005                 arg->params.counter_info_version_out = 0x8;
1006         }
1007
1008         /*
1009          * Use counter_info_version_out value to assign
1010          * required hv-gpci event list.
1011          */
1012         if (arg->params.counter_info_version_out >= 0x8)
1013                 event_group.attrs = hv_gpci_event_attrs;
1014         else
1015                 event_group.attrs = hv_gpci_event_attrs_v6;
1016
1017         put_cpu_var(hv_gpci_reqb);
1018
1019         r = perf_pmu_register(&h_gpci_pmu, h_gpci_pmu.name, -1);
1020         if (r)
1021                 return r;
1022
1023         /* sysinfo interface files are only available for power10 and above platforms */
1024         if (PVR_VER(mfspr(SPRN_PVR)) >= PVR_POWER10)
1025                 add_sysinfo_interface_files();
1026
1027         return 0;
1028 }
1029
1030 device_initcall(hv_gpci_init);