/*

 * pfmlib_common.c: set of functions common to all PMU models

 *

 * Copyright (c) 2009 Google, Inc

 * Contributed by Stephane Eranian <eranian@gmail.com>

 *

 * Based on:

 * Copyright (c) 2001-2006 Hewlett-Packard Development Company, L.P.

 * Contributed by Stephane Eranian <eranian@hpl.hp.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

 * of the Software, and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in all

 * copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,

 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE

 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#include <sys/types.h>

#include <ctype.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <limits.h>

#include <perfmon/pfmlib.h>

#include "pfmlib_priv.h"

static pfmlib_pmu_t *pfmlib_pmus[]=

{

#ifdef CONFIG_PFMLIB_ARCH_IA64

#if 0

	&montecito_support,

	&itanium2_support,

	&itanium_support,

	&generic_ia64_support,	/* must always be last for IA-64 */

#endif

#endif

#ifdef CONFIG_PFMLIB_ARCH_I386

	/* 32-bit only processors */

	&intel_pii_support,

	&intel_ppro_support,

	&intel_p6_support,

	&intel_pm_support,

	&intel_coreduo_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_X86

	/* 32 and 64 bit processors */

	&netburst_support,

	&netburst_p_support,

	&amd64_k7_support,

	&amd64_k8_revb_support,

	&amd64_k8_revc_support,

	&amd64_k8_revd_support,

	&amd64_k8_reve_support,

	&amd64_k8_revf_support,

	&amd64_k8_revg_support,

	&amd64_fam10h_barcelona_support,

	&amd64_fam10h_shanghai_support,

	&amd64_fam10h_istanbul_support,

	&amd64_fam11h_turion_support,

	&amd64_fam12h_llano_support,

	&amd64_fam14h_bobcat_support,

	&amd64_fam15h_interlagos_support,

	&amd64_fam15h_nb_support,

	&amd64_fam16h_support,

	&amd64_fam17h_support,

	&intel_core_support,

	&intel_atom_support,

	&intel_nhm_support,

	&intel_nhm_ex_support,

	&intel_nhm_unc_support,

	&intel_wsm_sp_support,

	&intel_wsm_dp_support,

	&intel_wsm_unc_support,

	&intel_snb_support,

	&intel_snb_unc_cbo0_support,

	&intel_snb_unc_cbo1_support,

	&intel_snb_unc_cbo2_support,

	&intel_snb_unc_cbo3_support,

	&intel_snb_ep_support,

	&intel_ivb_support,

	&intel_ivb_unc_cbo0_support,

	&intel_ivb_unc_cbo1_support,

	&intel_ivb_unc_cbo2_support,

	&intel_ivb_unc_cbo3_support,

	&intel_ivb_ep_support,

	&intel_hsw_support,

	&intel_hsw_ep_support,

	&intel_bdw_support,

	&intel_bdw_ep_support,

	&intel_skl_support,

	&intel_skx_support,

	&intel_rapl_support,

	&intel_snbep_unc_cb0_support,

	&intel_snbep_unc_cb1_support,

	&intel_snbep_unc_cb2_support,

	&intel_snbep_unc_cb3_support,

	&intel_snbep_unc_cb4_support,

	&intel_snbep_unc_cb5_support,

	&intel_snbep_unc_cb6_support,

	&intel_snbep_unc_cb7_support,

	&intel_snbep_unc_ha_support,

	&intel_snbep_unc_imc0_support,

	&intel_snbep_unc_imc1_support,

	&intel_snbep_unc_imc2_support,

	&intel_snbep_unc_imc3_support,

	&intel_snbep_unc_pcu_support,

	&intel_snbep_unc_qpi0_support,

	&intel_snbep_unc_qpi1_support,

	&intel_snbep_unc_ubo_support,

	&intel_snbep_unc_r2pcie_support,

	&intel_snbep_unc_r3qpi0_support,

	&intel_snbep_unc_r3qpi1_support,

	&intel_knc_support,

	&intel_slm_support,

	&intel_glm_support,

	&intel_ivbep_unc_cb0_support,

	&intel_ivbep_unc_cb1_support,

	&intel_ivbep_unc_cb2_support,

	&intel_ivbep_unc_cb3_support,

	&intel_ivbep_unc_cb4_support,

	&intel_ivbep_unc_cb5_support,

	&intel_ivbep_unc_cb6_support,

	&intel_ivbep_unc_cb7_support,

	&intel_ivbep_unc_cb8_support,

	&intel_ivbep_unc_cb9_support,

	&intel_ivbep_unc_cb10_support,

	&intel_ivbep_unc_cb11_support,

	&intel_ivbep_unc_cb12_support,

	&intel_ivbep_unc_cb13_support,

	&intel_ivbep_unc_cb14_support,

	&intel_ivbep_unc_ha0_support,

	&intel_ivbep_unc_ha1_support,

	&intel_ivbep_unc_imc0_support,

	&intel_ivbep_unc_imc1_support,

	&intel_ivbep_unc_imc2_support,

	&intel_ivbep_unc_imc3_support,

	&intel_ivbep_unc_imc4_support,

	&intel_ivbep_unc_imc5_support,

	&intel_ivbep_unc_imc6_support,

	&intel_ivbep_unc_imc7_support,

	&intel_ivbep_unc_pcu_support,

	&intel_ivbep_unc_qpi0_support,

	&intel_ivbep_unc_qpi1_support,

	&intel_ivbep_unc_qpi2_support,

	&intel_ivbep_unc_ubo_support,

	&intel_ivbep_unc_r2pcie_support,

	&intel_ivbep_unc_r3qpi0_support,

	&intel_ivbep_unc_r3qpi1_support,

	&intel_ivbep_unc_r3qpi2_support,

	&intel_ivbep_unc_irp_support,

	&intel_hswep_unc_cb0_support,

	&intel_hswep_unc_cb1_support,

	&intel_hswep_unc_cb2_support,

	&intel_hswep_unc_cb3_support,

	&intel_hswep_unc_cb4_support,

	&intel_hswep_unc_cb5_support,

	&intel_hswep_unc_cb6_support,

	&intel_hswep_unc_cb7_support,

	&intel_hswep_unc_cb8_support,

	&intel_hswep_unc_cb9_support,

	&intel_hswep_unc_cb10_support,

	&intel_hswep_unc_cb11_support,

	&intel_hswep_unc_cb12_support,

	&intel_hswep_unc_cb13_support,

	&intel_hswep_unc_cb14_support,

	&intel_hswep_unc_cb15_support,

	&intel_hswep_unc_cb16_support,

	&intel_hswep_unc_cb17_support,

	&intel_hswep_unc_ha0_support,

	&intel_hswep_unc_ha1_support,

	&intel_hswep_unc_imc0_support,

	&intel_hswep_unc_imc1_support,

	&intel_hswep_unc_imc2_support,

	&intel_hswep_unc_imc3_support,

	&intel_hswep_unc_imc4_support,

	&intel_hswep_unc_imc5_support,

	&intel_hswep_unc_imc6_support,

	&intel_hswep_unc_imc7_support,

	&intel_hswep_unc_pcu_support,

	&intel_hswep_unc_qpi0_support,

	&intel_hswep_unc_qpi1_support,

	&intel_hswep_unc_sb0_support,

	&intel_hswep_unc_sb1_support,

	&intel_hswep_unc_sb2_support,

	&intel_hswep_unc_sb3_support,

	&intel_hswep_unc_ubo_support,

	&intel_hswep_unc_r2pcie_support,

	&intel_hswep_unc_r3qpi0_support,

	&intel_hswep_unc_r3qpi1_support,

	&intel_hswep_unc_r3qpi2_support,

	&intel_hswep_unc_irp_support,

	&intel_knl_support,

	&intel_knl_unc_imc0_support,

	&intel_knl_unc_imc1_support,

	&intel_knl_unc_imc2_support,

	&intel_knl_unc_imc3_support,

	&intel_knl_unc_imc4_support,

	&intel_knl_unc_imc5_support,

	&intel_knl_unc_imc_uclk0_support,

	&intel_knl_unc_imc_uclk1_support,

	&intel_knl_unc_edc_uclk0_support,

	&intel_knl_unc_edc_uclk1_support,

	&intel_knl_unc_edc_uclk2_support,

	&intel_knl_unc_edc_uclk3_support,

	&intel_knl_unc_edc_uclk4_support,

	&intel_knl_unc_edc_uclk5_support,

	&intel_knl_unc_edc_uclk6_support,

	&intel_knl_unc_edc_uclk7_support,

	&intel_knl_unc_edc_eclk0_support,

	&intel_knl_unc_edc_eclk1_support,

	&intel_knl_unc_edc_eclk2_support,

	&intel_knl_unc_edc_eclk3_support,

	&intel_knl_unc_edc_eclk4_support,

	&intel_knl_unc_edc_eclk5_support,

	&intel_knl_unc_edc_eclk6_support,

	&intel_knl_unc_edc_eclk7_support,

	&intel_knl_unc_cha0_support,

	&intel_knl_unc_cha1_support,

	&intel_knl_unc_cha2_support,

	&intel_knl_unc_cha3_support,

	&intel_knl_unc_cha4_support,

	&intel_knl_unc_cha5_support,

	&intel_knl_unc_cha6_support,

	&intel_knl_unc_cha7_support,

	&intel_knl_unc_cha8_support,

	&intel_knl_unc_cha9_support,

	&intel_knl_unc_cha10_support,

	&intel_knl_unc_cha11_support,

	&intel_knl_unc_cha12_support,

	&intel_knl_unc_cha13_support,

	&intel_knl_unc_cha14_support,

	&intel_knl_unc_cha15_support,

	&intel_knl_unc_cha16_support,

	&intel_knl_unc_cha17_support,

	&intel_knl_unc_cha18_support,

	&intel_knl_unc_cha19_support,

	&intel_knl_unc_cha20_support,

	&intel_knl_unc_cha21_support,

	&intel_knl_unc_cha22_support,

	&intel_knl_unc_cha23_support,

	&intel_knl_unc_cha24_support,

	&intel_knl_unc_cha25_support,

	&intel_knl_unc_cha26_support,

	&intel_knl_unc_cha27_support,

	&intel_knl_unc_cha28_support,

	&intel_knl_unc_cha29_support,

	&intel_knl_unc_cha30_support,

	&intel_knl_unc_cha31_support,

	&intel_knl_unc_cha32_support,

	&intel_knl_unc_cha33_support,

	&intel_knl_unc_cha34_support,

	&intel_knl_unc_cha35_support,

	&intel_knl_unc_cha36_support,

	&intel_knl_unc_cha37_support,

	&intel_knl_unc_m2pcie_support,

	&intel_bdx_unc_cb0_support,

	&intel_bdx_unc_cb1_support,

	&intel_bdx_unc_cb2_support,

	&intel_bdx_unc_cb3_support,

	&intel_bdx_unc_cb4_support,

	&intel_bdx_unc_cb5_support,

	&intel_bdx_unc_cb6_support,

	&intel_bdx_unc_cb7_support,

	&intel_bdx_unc_cb8_support,

	&intel_bdx_unc_cb9_support,

	&intel_bdx_unc_cb10_support,

	&intel_bdx_unc_cb11_support,

	&intel_bdx_unc_cb12_support,

	&intel_bdx_unc_cb13_support,

	&intel_bdx_unc_cb14_support,

	&intel_bdx_unc_cb15_support,

	&intel_bdx_unc_cb16_support,

	&intel_bdx_unc_cb17_support,

	&intel_bdx_unc_cb18_support,

	&intel_bdx_unc_cb19_support,

	&intel_bdx_unc_cb20_support,

	&intel_bdx_unc_cb21_support,

	&intel_bdx_unc_cb22_support,

	&intel_bdx_unc_cb23_support,

	&intel_bdx_unc_ubo_support,

	&intel_bdx_unc_sbo0_support,

	&intel_bdx_unc_sbo1_support,

	&intel_bdx_unc_sbo2_support,

	&intel_bdx_unc_sbo3_support,

	&intel_bdx_unc_ha0_support,

	&intel_bdx_unc_ha1_support,

	&intel_bdx_unc_imc0_support,

	&intel_bdx_unc_imc1_support,

	&intel_bdx_unc_imc2_support,

	&intel_bdx_unc_imc3_support,

	&intel_bdx_unc_imc4_support,

	&intel_bdx_unc_imc5_support,

	&intel_bdx_unc_imc6_support,

	&intel_bdx_unc_imc7_support,

	&intel_bdx_unc_irp_support,

	&intel_bdx_unc_pcu_support,

	&intel_bdx_unc_qpi0_support,

	&intel_bdx_unc_qpi1_support,

	&intel_bdx_unc_qpi2_support,

	&intel_bdx_unc_r2pcie_support,

	&intel_bdx_unc_r3qpi0_support,

	&intel_bdx_unc_r3qpi1_support,

	&intel_bdx_unc_r3qpi2_support,

	&intel_x86_arch_support, /* must always be last for x86 */

#endif

#ifdef CONFIG_PFMLIB_ARCH_MIPS

	&mips_74k_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_SICORTEX

	&sicortex_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_POWERPC

	&power4_support,

	&ppc970_support,

	&ppc970mp_support,

	&power5_support,

	&power5p_support,

	&power6_support,

	&power7_support,

	&power8_support,

	&power9_support,

	&torrent_support,

    &powerpc_nest_mcs_read_support,

    &powerpc_nest_mcs_write_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_SPARC

	&sparc_ultra12_support,

	&sparc_ultra3_support,

	&sparc_ultra3i_support,

	&sparc_ultra3plus_support,

	&sparc_ultra4plus_support,

	&sparc_niagara1_support,

	&sparc_niagara2_support,

#endif

#ifdef CONFIG_PFMLIB_CELL

	&cell_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_ARM

	&arm_cortex_a7_support,

	&arm_cortex_a8_support,

	&arm_cortex_a9_support,

	&arm_cortex_a15_support,

	&arm_1176_support,

	&arm_qcom_krait_support,

	&arm_cortex_a57_support,

	&arm_cortex_a53_support,

	&arm_xgene_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_ARM64

	&arm_cortex_a57_support,

	&arm_cortex_a53_support,

	&arm_xgene_support,

#endif

#ifdef CONFIG_PFMLIB_ARCH_S390X

	&s390x_cpum_cf_support,

	&s390x_cpum_sf_support,

#endif

#ifdef __linux__

	&perf_event_support,

	&perf_event_raw_support,

#endif

};

#define PFMLIB_NUM_PMUS	(int)(sizeof(pfmlib_pmus)/sizeof(pfmlib_pmu_t *))

static pfmlib_os_t pfmlib_os_none;

pfmlib_os_t *pfmlib_os = &pfmlib_os_none;

static pfmlib_os_t *pfmlib_oses[]={

	&pfmlib_os_none,

#ifdef __linux__

	&pfmlib_os_perf,

	&pfmlib_os_perf_ext,

#endif

};

#define PFMLIB_NUM_OSES	(int)(sizeof(pfmlib_oses)/sizeof(pfmlib_os_t *))

/*

 * Mapping table from PMU index to pfmlib_pmu_t

 * table is populated from pfmlib_pmus[] when the library

 * is initialized.

 *

 * Some entries can be NULL if PMU is not implemented on host

 * architecture or if the initialization failed.

 */

static pfmlib_pmu_t *pfmlib_pmus_map[PFM_PMU_MAX];

#define pfmlib_for_each_pmu_event(p, e) \

	for(e=(p)->get_event_first((p)); e != -1; e = (p)->get_event_next((p), e))

#define for_each_pmu_event_attr(u, i) \

	for((u)=0; (u) < (i)->nattrs; (u) = (u)+1)

#define pfmlib_for_each_pmu(x) \

	for((x)= 0 ; (x) < PFMLIB_NUM_PMUS; (x)++)

#define pfmlib_for_each_pmu(x) \

	for((x)= 0 ; (x) < PFMLIB_NUM_PMUS; (x)++)

#define pfmlib_for_each_os(x) \

	for((x)= 0 ; (x) < PFMLIB_NUM_OSES; (x)++)

pfmlib_config_t pfm_cfg;

void

__pfm_dbprintf(const char *fmt, ...)

{

	va_list ap;

	if (pfm_cfg.debug == 0)

		return;

	va_start(ap, fmt);

	vfprintf(pfm_cfg.fp, fmt, ap);

	va_end(ap);

}

void

__pfm_vbprintf(const char *fmt, ...)

{

	va_list ap;

	if (pfm_cfg.verbose == 0)

		return;

	va_start(ap, fmt);

	vfprintf(pfm_cfg.fp, fmt, ap);

	va_end(ap);

}

/*

 * pfmlib_getl: our own equivalent to GNU getline() extension.

 * This avoids a dependency on having a C library with

 * support for getline().

 */

int

pfmlib_getl(char **buffer, size_t *len, FILE *fp)

{

#define	GETL_DFL_LEN	32

	char *b;

	int c;

	size_t maxsz, maxi, d, i = 0;

	if (!len || !fp || !buffer || (*buffer && *len < 2))

		return -1;

	b = *buffer;

	if (!b)

		*len = 0;

	maxsz = *len;

	maxi = maxsz - 2;

	while ((c = fgetc(fp)) != EOF) {

		if (maxsz == 0 || i == maxi) {

			if (maxsz == 0)

				maxsz = GETL_DFL_LEN;

			else

				maxsz <<= 1;

			if (*buffer)

				d = &b[i] - *buffer;

			else

				d = 0;

			*buffer = realloc(*buffer, maxsz);

			if (!*buffer)

				return -1;

			b = *buffer + d;

			maxi = maxsz - d - 2;

			i = 0;

			*len = maxsz;

		}

		b[i++] = c;

		if (c == '\n')

			break;

	}

	b[i] = '\0';

	return c != EOF ? 0 : -1;

}

/*

 * append fmt+args to str such that the string is no

 * more than max characters incl. null termination

 */

void

pfmlib_strconcat(char *str, size_t max, const char *fmt, ...)

{

	va_list ap;

	size_t len, todo;

	len = strlen(str);

	todo = max - strlen(str);

	va_start(ap, fmt);

	vsnprintf(str+len, todo, fmt, ap);

	va_end(ap);

}

/*

 * compact all pattrs starting from index i

 */

void

pfmlib_compact_pattrs(pfmlib_event_desc_t *e, int i)

{

	int j;

	for (j = i+1; j < e->npattrs; j++)

		e->pattrs[j - 1] = e->pattrs[j];

	e->npattrs--;

}

static void

pfmlib_compact_attrs(pfmlib_event_desc_t *e, int i)

{

	int j;

	for (j = i+1; j < e->nattrs; j++)

		e->attrs[j - 1] = e->attrs[j];

	e->nattrs--;

}

/*

 *  0 : different attribute

 *  1 : exactly same attribute (duplicate can be removed)

 * -1 : same attribute but value differ, this is an error

 */

static inline int

pfmlib_same_attr(pfmlib_event_desc_t *d, int i, int j)

{

	pfmlib_event_attr_info_t *a1, *a2;

	pfmlib_attr_t *b1, *b2;

	a1 = attr(d, i);

	a2 = attr(d, j);

	b1 = d->attrs+i;

	b2 = d->attrs+j;

	if (a1->idx == a2->idx

	    && a1->type == a2->type

	    && a1->ctrl == a2->ctrl) {

		if (b1->ival == b2->ival)

			return 1;

		return -1;

	}

	return 0;

}

static inline int

pfmlib_pmu_active(pfmlib_pmu_t *pmu)

{

        return !!(pmu->flags & PFMLIB_PMU_FL_ACTIVE);

}

static inline int

pfmlib_pmu_initialized(pfmlib_pmu_t *pmu)

{

        return !!(pmu->flags & PFMLIB_PMU_FL_INIT);

}

static inline pfm_pmu_t

idx2pmu(int idx)

{

	return (pfm_pmu_t)(idx >> PFMLIB_PMU_SHIFT) & PFMLIB_PMU_MASK;

}

static inline pfmlib_pmu_t *

pmu2pmuidx(pfm_pmu_t pmu)

{

	/* pfm_pmu_t is unsigned int enum, so

	 * just need to check for upper bound

	 */

	if (pmu >= PFM_PMU_MAX)

		return NULL;

	return pfmlib_pmus_map[pmu];

}

/*

 * external opaque idx -> PMU + internal idx

 */

static pfmlib_pmu_t *

pfmlib_idx2pidx(int idx, int *pidx)

{

	pfmlib_pmu_t *pmu;

	pfm_pmu_t pmu_id;

	if (PFMLIB_INITIALIZED() == 0)

		return NULL;

	if (idx < 0)

		return NULL;

	pmu_id = idx2pmu(idx);

	pmu = pmu2pmuidx(pmu_id);

	if (!pmu)

		return NULL;

	*pidx = idx & PFMLIB_PMU_PIDX_MASK;

	if (!pmu->event_is_valid(pmu, *pidx))

		return NULL;

	return pmu;

}

static pfmlib_os_t *

pfmlib_find_os(pfm_os_t id)

{

	int o;

	pfmlib_os_t *os;

	pfmlib_for_each_os(o) {

		os = pfmlib_oses[o];

		if (os->id == id && (os->flags & PFMLIB_OS_FL_ACTIVATED))

			return os;

	}

	return NULL;

}

size_t

pfmlib_check_struct(void *st, size_t usz, size_t refsz, size_t sz)

{

	size_t rsz = sz;

	/*

	 * if user size is zero, then use ABI0 size

	 */

	if (usz == 0)

		usz = refsz;

	/*

	 * cannot be smaller than ABI0 size

	 */

	if (usz < refsz) {

		DPRINT("pfmlib_check_struct: user size too small %zu\n", usz);

		return 0;

	}

	/*

	 * if bigger than current ABI, then check that none

	 * of the extra bits are set. This is to avoid mistake

	 * by caller assuming the library set those bits.

	 */

	if (usz > sz) {

		char *addr = (char *)st + sz;

		char *end = (char *)st + usz;

		while (addr != end) {

			if (*addr++) {

				DPRINT("pfmlib_check_struct: invalid extra bits\n");

				return 0;

			}

		}

	}

	return rsz;

}

/*

 * check environment variables for:

 *  LIBPFM_VERBOSE : enable verbose output (must be 1)

 *  LIBPFM_DEBUG   : enable debug output (must be 1)

 */

static void

pfmlib_init_env(void)

{

	char *str;

	pfm_cfg.fp = stderr;

	str = getenv("LIBPFM_VERBOSE");

	if (str && isdigit((int)*str))

		pfm_cfg.verbose = *str - '0';

	str = getenv("LIBPFM_DEBUG");

	if (str && isdigit((int)*str))

		pfm_cfg.debug = *str - '0';

	str = getenv("LIBPFM_DEBUG_STDOUT");

	if (str)

		pfm_cfg.fp = stdout;

	pfm_cfg.forced_pmu = getenv("LIBPFM_FORCE_PMU");

	str = getenv("LIBPFM_ENCODE_INACTIVE");

	if (str)

		pfm_cfg.inactive = 1;

	str = getenv("LIBPFM_DISABLED_PMUS");

	if (str)

		pfm_cfg.blacklist_pmus = str;

}

static int

pfmlib_pmu_sanity_checks(pfmlib_pmu_t *p)

{

	/*

	 * check event can be encoded

	 */

	if (p->pme_count >= (1<< PFMLIB_PMU_SHIFT)) {

		DPRINT("too many events for %s\n", p->desc);

		return PFM_ERR_NOTSUPP;

	}

	if (p->max_encoding > PFMLIB_MAX_ENCODING) {

		DPRINT("max encoding too high (%d > %d) for %s\n",

			p->max_encoding, PFMLIB_MAX_ENCODING, p->desc);

		return PFM_ERR_NOTSUPP;

	}

	return PFM_SUCCESS;

}

int

pfmlib_build_fstr(pfmlib_event_desc_t *e, char **fstr)

{

	/* nothing to do */

	if (!fstr)

		return PFM_SUCCESS;

	*fstr = malloc(strlen(e->fstr) + 2 + strlen(e->pmu->name) + 1);

	if (*fstr)

		sprintf(*fstr, "%s::%s", e->pmu->name, e->fstr);

	return *fstr ? PFM_SUCCESS : PFM_ERR_NOMEM;

}

static int

pfmlib_pmu_activate(pfmlib_pmu_t *p)

{

	int ret;

	if (p->pmu_init) {

		ret = p->pmu_init(p);

		if (ret != PFM_SUCCESS)

			return ret;

	}

	p->flags |= PFMLIB_PMU_FL_ACTIVE;

	DPRINT("activated %s\n", p->desc);

	return PFM_SUCCESS;	

}

static inline int

pfmlib_match_forced_pmu(const char *name)

{

	const char *p;

	size_t l;

	/* skip any lower level specifier */

	p = strchr(pfm_cfg.forced_pmu, ',');

	if (p)

		l = p - pfm_cfg.forced_pmu;

	else

		l = strlen(pfm_cfg.forced_pmu);

	return !strncasecmp(name, pfm_cfg.forced_pmu, l);

}

static int

pfmlib_is_blacklisted_pmu(pfmlib_pmu_t *p)

{

	char *q, *buffer;

	int ret = 1;

	if (!pfm_cfg.blacklist_pmus)

		return 0;

	/*

	 * scan list for matching PMU names, we accept substrings.

	 * for instance: snbep does match snbep*

	 */

	buffer = strdup(pfm_cfg.blacklist_pmus);

	if (!buffer)

		return 0;

	strcpy (buffer, pfm_cfg.blacklist_pmus);

	for (q = strtok (buffer, ","); q != NULL; q = strtok (NULL, ",")) {

		if (strstr (p->name, q) != NULL) {

			goto done;

		}

	}

	ret = 0;

done:

	free(buffer);

	return ret;

}

static int

pfmlib_init_pmus(void)

{

	pfmlib_pmu_t *p;

	int i, ret;

	int nsuccess = 0;

	/*

	 * activate all detected PMUs

	 * when forced, only the designated PMU

	 * is setup and activated

	 */

	pfmlib_for_each_pmu(i) {

		p = pfmlib_pmus[i];

		DPRINT("trying %s\n", p->desc);

		ret = PFM_SUCCESS;

		if (!pfm_cfg.forced_pmu)

			ret = p->pmu_detect(p);

		else if (!pfmlib_match_forced_pmu(p->name))

			ret = PFM_ERR_NOTSUPP;

		/*

		 * basic checks

		 * failure causes PMU to not be available

		 */

		if (pfmlib_pmu_sanity_checks(p) != PFM_SUCCESS)

			continue;

		if (pfmlib_is_blacklisted_pmu(p)) {

			DPRINT("%d PMU blacklisted, skipping initialization\n");

			continue;

		}

		p->flags |= PFMLIB_PMU_FL_INIT;

		/*

		 * populate mapping table

		 */

		pfmlib_pmus_map[p->pmu] = p;

		if (ret != PFM_SUCCESS)

			continue;

		/*

		 * check if exported by OS if needed

		 */

		if (p->os_detect[pfmlib_os->id]) {

			ret = p->os_detect[pfmlib_os->id](p);

			if (ret != PFM_SUCCESS) {

				DPRINT("%s PMU not exported by OS\n", p->name);

				continue;

			}

		}

		ret = pfmlib_pmu_activate(p);

		if (ret == PFM_SUCCESS)