// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2022, Athira Rajeev, IBM Corp.
 * Copyright 2022, Madhavan Srinivasan, IBM Corp.
 * Copyright 2022, Kajol Jain, IBM Corp.
 */

#include <unistd.h>
#include <sys/syscall.h>
#include <string.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <ctype.h>

#include "misc.h"

#define PAGE_SIZE               sysconf(_SC_PAGESIZE)

/* Storage for platform version */
int pvr;
u64 platform_extended_mask;

/* Mask and Shift for Event code fields */
int ev_mask_pmcxsel, ev_shift_pmcxsel;  //pmcxsel field
int ev_mask_marked, ev_shift_marked;  //marked filed
int ev_mask_comb, ev_shift_comb;  //combine field
int ev_mask_unit, ev_shift_unit;  //unit field
int ev_mask_pmc, ev_shift_pmc;   //pmc field
int ev_mask_cache, ev_shift_cache;  //Cache sel field
int ev_mask_sample, ev_shift_sample;  //Random sampling field
int ev_mask_thd_sel, ev_shift_thd_sel;  //thresh_sel field
int ev_mask_thd_start, ev_shift_thd_start; //thresh_start field
int ev_mask_thd_stop, ev_shift_thd_stop; //thresh_stop field
int ev_mask_thd_cmp, ev_shift_thd_cmp;  //thresh cmp field
int ev_mask_sm, ev_shift_sm;   //SDAR mode field
int ev_mask_rsq, ev_shift_rsq;   //radix scope qual field
int ev_mask_l2l3, ev_shift_l2l3;  //l2l3 sel field
int ev_mask_mmcr3_src, ev_shift_mmcr3_src; //mmcr3 field

static void init_ev_encodes(void)
{
 ev_mask_pmcxsel = 0xff;
 ev_shift_pmcxsel = 0;
 ev_mask_marked = 1;
 ev_shift_marked = 8;
 ev_mask_unit = 0xf;
 ev_shift_unit = 12;
 ev_mask_pmc = 0xf;
 ev_shift_pmc = 16;
 ev_mask_sample = 0x1f;
 ev_shift_sample = 24;
 ev_mask_thd_sel = 0x7;
 ev_shift_thd_sel = 29;
 ev_mask_thd_start = 0xf;
 ev_shift_thd_start = 36;
 ev_mask_thd_stop = 0xf;
 ev_shift_thd_stop = 32;

 switch (pvr) {
 case POWER11:
 case POWER10:
  ev_mask_thd_cmp = 0x3ffff;
  ev_shift_thd_cmp = 0;
  ev_mask_rsq = 1;
  ev_shift_rsq = 9;
  ev_mask_comb = 3;
  ev_shift_comb = 10;
  ev_mask_cache = 3;
  ev_shift_cache = 20;
  ev_mask_sm = 0x3;
  ev_shift_sm = 22;
  ev_mask_l2l3 = 0x1f;
  ev_shift_l2l3 = 40;
  ev_mask_mmcr3_src = 0x7fff;
  ev_shift_mmcr3_src = 45;
  break;
 case POWER9:
  ev_mask_comb = 3;
  ev_shift_comb = 10;
  ev_mask_cache = 0xf;
  ev_shift_cache = 20;
  ev_mask_thd_cmp = 0x3ff;
  ev_shift_thd_cmp = 40;
  ev_mask_sm = 0x3;
  ev_shift_sm = 50;
  break;
 default:
  FAIL_IF_EXIT(1);
 }
}

/* Return the extended regs mask value */
u64 perf_get_platform_reg_mask(void)
{
 if (have_hwcap2(PPC_FEATURE2_ARCH_3_1))
  return PERF_POWER10_MASK;
 if (have_hwcap2(PPC_FEATURE2_ARCH_3_00))
  return PERF_POWER9_MASK;

 return -1;
}

int check_extended_regs_support(void)
{
 int fd;
 struct event event;

 event_init(&event, 0x1001e);

 event.attr.type = 4;
 event.attr.sample_period = 1;
 event.attr.disabled = 1;
 event.attr.sample_type = PERF_SAMPLE_REGS_INTR;
 event.attr.sample_regs_intr = platform_extended_mask;

 fd = event_open(&event);
 if (fd != -1)
  return 0;

 return -1;
}

int platform_check_for_tests(void)
{
 pvr = PVR_VER(mfspr(SPRN_PVR));

 /*
  * Check for supported platforms
  * for sampling test
 */
 switch (pvr) {
 case POWER11:
 case POWER10:
 case POWER9:
  break;
 default:
  goto out;
 }

 /*
  * Check PMU driver registered by looking for
  * PPC_FEATURE2_EBB bit in AT_HWCAP2
 */
 if (!have_hwcap2(PPC_FEATURE2_EBB) || !have_hwcap2(PPC_FEATURE2_ARCH_3_00))
  goto out;

 return 0;

out:
 printf("%s: Tests unsupported for this platform\n", __func__);
 return -1;
}

int check_pvr_for_sampling_tests(void)
{
 SKIP_IF(platform_check_for_tests());

 platform_extended_mask = perf_get_platform_reg_mask();
 /* check if platform supports extended regs */
 if (check_extended_regs_support())
  goto out;

 init_ev_encodes();
 return 0;

out:
 printf("%s: Sampling tests un-supported\n", __func__);
 return -1;
}

/*
 * Allocate mmap buffer of "mmap_pages" number of
 * pages.
 */
void *event_sample_buf_mmap(int fd, int mmap_pages)
{
 size_t page_size = sysconf(_SC_PAGESIZE);
 size_t mmap_size;
 void *buff;

 if (mmap_pages <= 0)
  return NULL;

 if (fd <= 0)
  return NULL;

 mmap_size =  page_size * (1 + mmap_pages);
 buff = mmap(NULL, mmap_size,
  PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

 if (buff == MAP_FAILED) {
  perror("mmap() failed.");
  return NULL;
 }
 return buff;
}

/*
 * Post process the mmap buffer.
 * - If sample_count != NULL then return count of total
 *   number of samples present in the mmap buffer.
 * - If sample_count == NULL then return the address
 *   of first sample from the mmap buffer
 */
void *__event_read_samples(void *sample_buff, size_t *size, u64 *sample_count)
{
 size_t page_size = sysconf(_SC_PAGESIZE);
 struct perf_event_header *header = sample_buff + page_size;
 struct perf_event_mmap_page *metadata_page = sample_buff;
 unsigned long data_head, data_tail;

 /*
  * PERF_RECORD_SAMPLE:
  * struct {
  *     struct perf_event_header hdr;
  *     u64 data[];
  * };
 */

 data_head = metadata_page->data_head;
 /* sync memory before reading sample */
 mb();
 data_tail = metadata_page->data_tail;

 /* Check for sample_count */
 if (sample_count)
  *sample_count = 0;

 while (1) {
  /*
   * Reads the mmap data buffer by moving
   * the data_tail to know the last read data.
   * data_head points to head in data buffer.
   * refer "struct perf_event_mmap_page" in
   * "include/uapi/linux/perf_event.h".
 */
  if (data_head - data_tail < sizeof(header))
   return NULL;

  data_tail += sizeof(header);
  if (header->type == PERF_RECORD_SAMPLE) {
   *size = (header->size - sizeof(header));
   if (!sample_count)
    return sample_buff + page_size + data_tail;
   data_tail += *size;
   *sample_count += 1;
  } else {
   *size = (header->size - sizeof(header));
   if ((metadata_page->data_tail + *size) > metadata_page->data_head)
    data_tail = metadata_page->data_head;
   else
    data_tail += *size;
  }
  header = (struct perf_event_header *)((void *)header + header->size);
 }
 return NULL;
}

int collect_samples(void *sample_buff)
{
 u64 sample_count;
 size_t size = 0;

 __event_read_samples(sample_buff, &size, &sample_count);
 return sample_count;
}

static void *perf_read_first_sample(void *sample_buff, size_t *size)
{
 return __event_read_samples(sample_buff, size, NULL);
}

u64 *get_intr_regs(struct event *event, void *sample_buff)
{
 u64 type = event->attr.sample_type;
 u64 *intr_regs;
 size_t size = 0;

 if ((type ^ (PERF_SAMPLE_REGS_INTR | PERF_SAMPLE_BRANCH_STACK)) &&
   (type  ^ PERF_SAMPLE_REGS_INTR))
  return NULL;

 intr_regs = (u64 *)perf_read_first_sample(sample_buff, &size);
 if (!intr_regs)
  return NULL;

 if (type & PERF_SAMPLE_BRANCH_STACK) {
  /*
   * PERF_RECORD_SAMPLE and PERF_SAMPLE_BRANCH_STACK:
   * struct {
   *     struct perf_event_header hdr;
   *     u64 number_of_branches;
   *     struct perf_branch_entry[number_of_branches];
   *     u64 data[];
   * };
   * struct perf_branch_entry {
   *     u64 from;
   *     u64 to;
   *     u64 misc;
   * };
 */
  intr_regs += ((*intr_regs) * 3) + 1;
 }

 /*
  * First entry in the sample buffer used to specify
  * PERF_SAMPLE_REGS_ABI_64, skip perf regs abi to access
  * interrupt registers.
 */
 ++intr_regs;

 return intr_regs;
}

static const int __perf_reg_mask(const char *register_name)
{
 if (!strcmp(register_name, "R0"))
  return 0;
 else if (!strcmp(register_name, "R1"))
  return 1;
 else if (!strcmp(register_name, "R2"))
  return 2;
 else if (!strcmp(register_name, "R3"))
  return 3;
 else if (!strcmp(register_name, "R4"))
  return 4;
 else if (!strcmp(register_name, "R5"))
  return 5;
 else if (!strcmp(register_name, "R6"))
  return 6;
 else if (!strcmp(register_name, "R7"))
  return 7;
 else if (!strcmp(register_name, "R8"))
  return 8;
 else if (!strcmp(register_name, "R9"))
  return 9;
 else if (!strcmp(register_name, "R10"))
  return 10;
 else if (!strcmp(register_name, "R11"))
  return 11;
 else if (!strcmp(register_name, "R12"))
  return 12;
 else if (!strcmp(register_name, "R13"))
  return 13;
 else if (!strcmp(register_name, "R14"))
  return 14;
 else if (!strcmp(register_name, "R15"))
  return 15;
 else if (!strcmp(register_name, "R16"))
  return 16;
 else if (!strcmp(register_name, "R17"))
  return 17;
 else if (!strcmp(register_name, "R18"))
  return 18;
 else if (!strcmp(register_name, "R19"))
  return 19;
 else if (!strcmp(register_name, "R20"))
  return 20;
 else if (!strcmp(register_name, "R21"))
  return 21;
 else if (!strcmp(register_name, "R22"))
  return 22;
 else if (!strcmp(register_name, "R23"))
  return 23;
 else if (!strcmp(register_name, "R24"))
  return 24;
 else if (!strcmp(register_name, "R25"))
  return 25;
 else if (!strcmp(register_name, "R26"))
  return 26;
 else if (!strcmp(register_name, "R27"))
  return 27;
 else if (!strcmp(register_name, "R28"))
  return 28;
 else if (!strcmp(register_name, "R29"))
  return 29;
 else if (!strcmp(register_name, "R30"))
  return 30;
 else if (!strcmp(register_name, "R31"))
  return 31;
 else if (!strcmp(register_name, "NIP"))
  return 32;
 else if (!strcmp(register_name, "MSR"))
  return 33;
 else if (!strcmp(register_name, "ORIG_R3"))
  return 34;
 else if (!strcmp(register_name, "CTR"))
  return 35;
 else if (!strcmp(register_name, "LINK"))
  return 36;
 else if (!strcmp(register_name, "XER"))
  return 37;
 else if (!strcmp(register_name, "CCR"))
  return 38;
 else if (!strcmp(register_name, "SOFTE"))
  return 39;
 else if (!strcmp(register_name, "TRAP"))
  return 40;
 else if (!strcmp(register_name, "DAR"))
  return 41;
 else if (!strcmp(register_name, "DSISR"))
  return 42;
 else if (!strcmp(register_name, "SIER"))
  return 43;
 else if (!strcmp(register_name, "MMCRA"))
  return 44;
 else if (!strcmp(register_name, "MMCR0"))
  return 45;
 else if (!strcmp(register_name, "MMCR1"))
  return 46;
 else if (!strcmp(register_name, "MMCR2"))
  return 47;
 else if (!strcmp(register_name, "MMCR3"))
  return 48;
 else if (!strcmp(register_name, "SIER2"))
  return 49;
 else if (!strcmp(register_name, "SIER3"))
  return 50;
 else if (!strcmp(register_name, "PMC1"))
  return 51;
 else if (!strcmp(register_name, "PMC2"))
  return 52;
 else if (!strcmp(register_name, "PMC3"))
  return 53;
 else if (!strcmp(register_name, "PMC4"))
  return 54;
 else if (!strcmp(register_name, "PMC5"))
  return 55;
 else if (!strcmp(register_name, "PMC6"))
  return 56;
 else if (!strcmp(register_name, "SDAR"))
  return 57;
 else if (!strcmp(register_name, "SIAR"))
  return 58;
 else
  return -1;
}

u64 get_reg_value(u64 *intr_regs, char *register_name)
{
 int register_bit_position;

 register_bit_position = __perf_reg_mask(register_name);

 if (register_bit_position < 0 || (!((platform_extended_mask >>
   (register_bit_position - 1)) & 1)))
  return -1;

 return *(intr_regs + register_bit_position);
}

int get_thresh_cmp_val(struct event event)
{
 int exp = 0;
 u64 result = 0;
 u64 value;

 if (!have_hwcap2(PPC_FEATURE2_ARCH_3_1))
  return EV_CODE_EXTRACT(event.attr.config, thd_cmp);

 value = EV_CODE_EXTRACT(event.attr.config1, thd_cmp);

 if (!value)
  return value;

 /*
  * Incase of P10, thresh_cmp value is not part of raw event code
  * and provided via attr.config1 parameter. To program threshold in MMCRA,
  * take a 18 bit number N and shift right 2 places and increment
  * the exponent E by 1 until the upper 10 bits of N are zero.
  * Write E to the threshold exponent and write the lower 8 bits of N
  * to the threshold mantissa.
  * The max threshold that can be written is 261120.
 */
 if (value > 261120)
  value = 261120;
 while ((64 - __builtin_clzl(value)) > 8) {
  exp++;
  value >>= 2;
 }

 /*
  * Note that it is invalid to write a mantissa with the
  * upper 2 bits of mantissa being zero, unless the
  * exponent is also zero.
 */
 if (!(value & 0xC0) && exp)
  result = -1;
 else
  result = (exp << 8) | value;
 return result;
}

/*
 * Utility function to check for generic compat PMU
 * by comparing base_platform value from auxv and real
 * PVR value.
 * auxv_base_platform() func gives information of "base platform"
 * corresponding to PVR value. Incase, if the distro doesn't
 * support platform PVR (missing cputable support), base platform
 * in auxv will have a default value other than the real PVR's.
 * In this case, ISAv3 PMU (generic compat PMU) will be registered
 * in the system. auxv_generic_compat_pmu() makes use of the base
 * platform value from auxv to do this check.
 */
static bool auxv_generic_compat_pmu(void)
{
 int base_pvr = 0;

 if (!strcmp(auxv_base_platform(), "power9"))
  base_pvr = POWER9;
 else if (!strcmp(auxv_base_platform(), "power10"))
  base_pvr = POWER10;
 else if (!strcmp(auxv_base_platform(), "power11"))
  base_pvr = POWER11;

 return (!base_pvr);
}

/*
 * Check for generic compat PMU.
 * First check for presence of pmu_name from
 * "/sys/bus/event_source/devices/cpu/caps".
 * If doesn't exist, fallback to using value
 * auxv.
 */
bool check_for_generic_compat_pmu(void)
{
 char pmu_name[256];

 memset(pmu_name, 0, sizeof(pmu_name));
 if (read_sysfs_file("bus/event_source/devices/cpu/caps/pmu_name",
  pmu_name, sizeof(pmu_name)) < 0)
  return auxv_generic_compat_pmu();

 if (!strcmp(pmu_name, "ISAv3"))
  return true;
 else
  return false;
}

/*
 * Check if system is booted in compat mode.
 */
bool check_for_compat_mode(void)
{
 char *platform = auxv_platform();
 char *base_platform = auxv_base_platform();

 return strcmp(platform, base_platform);
}