/*

* File:    perfmon.c

* Author:  Philip Mucci

*          mucci@cs.utk.edu

* Mods:    Brian Sheely

*          bsheely@eecs.utk.edu

*/

/* TODO LIST:

   - Events for all platforms

   - Derived events for all platforms

   - Latency profiling

   - BTB/IPIEAR sampling

   - Test on ITA2, Pentium 4

   - hwd_ntv_code_to_name

   - Make native map carry major events, not umasks

   - Enum event uses native_map not pfm()

   - Hook up globals to be freed to sub_info

   - Better feature bit support for IEAR

*/

#include "papi.h"

#include "papi_internal.h"

#include "papi_vector.h"

#include "papi_memory.h"

#include "papi_libpfm_events.h"

#include "extras.h"

#include "perfmon.h"

#include "linux-memory.h"

#include "linux-timer.h"

#include "linux-common.h"

#ifdef __ia64__

#include "perfmon/pfmlib_itanium2.h"

#include "perfmon/pfmlib_montecito.h"

#endif

typedef unsigned uint;

/* Advance declarations */

static int _papi_pfm_set_overflow( EventSetInfo_t * ESI, int EventIndex,

							int threshold );

papi_vector_t _perfmon2_vector;

/* Static locals */

static int _perfmon2_pfm_pmu_type = -1;

static pfmlib_regmask_t _perfmon2_pfm_unavailable_pmcs;

static pfmlib_regmask_t _perfmon2_pfm_unavailable_pmds;

/* Debug functions */

#ifdef DEBUG

static void

dump_smpl_arg( pfm_dfl_smpl_arg_t * arg )

{

	SUBDBG( "SMPL_ARG.buf_size = %llu\n",

			( unsigned long long ) arg->buf_size );

	SUBDBG( "SMPL_ARG.buf_flags = %d\n", arg->buf_flags );

}

static void

dump_sets( pfarg_setdesc_t * set, int num_sets )

{

	int i;

	for ( i = 0; i < num_sets; i++ ) {

		SUBDBG( "SET[%d]\n", i );

		SUBDBG( "SET[%d].set_id = %d\n", i, set[i].set_id );

		// SUBDBG("SET[%d].set_id_next = %d\n",i,set[i].set_id_next);

		SUBDBG( "SET[%d].set_flags = %d\n", i, set[i].set_flags );

		SUBDBG( "SET[%d].set_timeout = %llu\n", i,

				( unsigned long long ) set[i].set_timeout );

		//  SUBDBG("SET[%d].set_mmap_offset = %#016llx\n",i,(unsigned long long)set[i].set_mmap_offset);

	}

}

static void

dump_setinfo( pfarg_setinfo_t * setinfo, int num_sets )

{

	int i;

	for ( i = 0; i < num_sets; i++ ) {

		SUBDBG( "SETINFO[%d]\n", i );

		SUBDBG( "SETINFO[%d].set_id = %d\n", i, setinfo[i].set_id );

		// SUBDBG("SETINFO[%d].set_id_next = %d\n",i,setinfo[i].set_id_next);

		SUBDBG( "SETINFO[%d].set_flags = %d\n", i, setinfo[i].set_flags );

		SUBDBG( "SETINFO[%d].set_ovfl_pmds[0] = %#016llx\n", i,

				( unsigned long long ) setinfo[i].set_ovfl_pmds[0] );

		SUBDBG( "SETINFO[%d].set_runs = %llu\n", i,

				( unsigned long long ) setinfo[i].set_runs );

		SUBDBG( "SETINFO[%d].set_timeout = %llu\n", i,

				( unsigned long long ) setinfo[i].set_timeout );

		SUBDBG( "SETINFO[%d].set_act_duration = %llu\n", i,

				( unsigned long long ) setinfo[i].set_act_duration );

		// SUBDBG("SETINFO[%d].set_mmap_offset = %#016llx\n",i,(unsigned long long)setinfo[i].set_mmap_offset);

		SUBDBG( "SETINFO[%d].set_avail_pmcs[0] = %#016llx\n", i,

				( unsigned long long ) setinfo[i].set_avail_pmcs[0] );

		SUBDBG( "SETINFO[%d].set_avail_pmds[0] = %#016llx\n", i,

				( unsigned long long ) setinfo[i].set_avail_pmds[0] );

	}

}

static void

dump_pmc( pfm_control_state_t * ctl )

{

	unsigned int i;

	pfarg_pmc_t *pc = ctl->pc;

	for ( i = 0; i < ctl->out.pfp_pmc_count; i++ ) {

		SUBDBG( "PC[%d]\n", i );

		SUBDBG( "PC[%d].reg_num = %d\n", i, pc[i].reg_num );

		SUBDBG( "PC[%d].reg_set = %d\n", i, pc[i].reg_set );

		SUBDBG( "PC[%d].reg_flags = %#08x\n", i, pc[i].reg_flags );

		SUBDBG( "PC[%d].reg_value = %#016llx\n", i,

				( unsigned long long ) pc[i].reg_value );

	}

}

static void

dump_pmd( pfm_control_state_t * ctl )

{

	unsigned int i;

	pfarg_pmd_t *pd = ctl->pd;

	for ( i = 0; i < ctl->in.pfp_event_count; i++ ) {

		SUBDBG( "PD[%d]\n", i );

		SUBDBG( "PD[%d].reg_num = %d\n", i, pd[i].reg_num );

		SUBDBG( "PD[%d].reg_set = %d\n", i, pd[i].reg_set );

		SUBDBG( "PD[%d].reg_flags = %#08x\n", i, pd[i].reg_flags );

		SUBDBG( "PD[%d].reg_value = %#016llx\n", i,

				( unsigned long long ) pd[i].reg_value );

		SUBDBG( "PD[%d].reg_long_reset = %llu\n", i,

				( unsigned long long ) pd[i].reg_long_reset );

		SUBDBG( "PD[%d].reg_short_reset = %llu\n", i,

				( unsigned long long ) pd[i].reg_short_reset );

		SUBDBG( "PD[%d].reg_last_reset_val = %llu\n", i,

				( unsigned long long ) pd[i].reg_last_reset_val );

		SUBDBG( "PD[%d].reg_ovfl_switch_cnt = %llu\n", i,

				( unsigned long long ) pd[i].reg_ovfl_switch_cnt );

		SUBDBG( "PD[%d].reg_reset_pmds[0] = %#016llx\n", i,

				( unsigned long long ) pd[i].reg_reset_pmds[0] );

		SUBDBG( "PD[%d].reg_smpl_pmds[0] = %#016llx\n", i,

				( unsigned long long ) pd[i].reg_smpl_pmds[0] );

		SUBDBG( "PD[%d].reg_smpl_eventid = %llu\n", i,

				( unsigned long long ) pd[i].reg_smpl_eventid );

		SUBDBG( "PD[%d].reg_random_mask = %llu\n", i,

				( unsigned long long ) pd[i].reg_random_mask );

		SUBDBG( "PD[%d].reg_random_seed = %d\n", i, pd[i].reg_random_seed );

	}

}

static void

dump_smpl_hdr( pfm_dfl_smpl_hdr_t * hdr )

{

	SUBDBG( "SMPL_HDR.hdr_count = %llu\n",

			( unsigned long long ) hdr->hdr_count );

	SUBDBG( "SMPL_HDR.hdr_cur_offs = %llu\n",

			( unsigned long long ) hdr->hdr_cur_offs );

	SUBDBG( "SMPL_HDR.hdr_overflows = %llu\n",

			( unsigned long long ) hdr->hdr_overflows );

	SUBDBG( "SMPL_HDR.hdr_buf_size = %llu\n",

			( unsigned long long ) hdr->hdr_buf_size );

	SUBDBG( "SMPL_HDR.hdr_min_buf_space = %llu\n",

			( unsigned long long ) hdr->hdr_min_buf_space );

	SUBDBG( "SMPL_HDR.hdr_version = %d\n", hdr->hdr_version );

	SUBDBG( "SMPL_HDR.hdr_buf_flags = %d\n", hdr->hdr_buf_flags );

}

static void

dump_smpl( pfm_dfl_smpl_entry_t * entry )

{

	SUBDBG( "SMPL.pid = %d\n", entry->pid );

	SUBDBG( "SMPL.ovfl_pmd = %d\n", entry->ovfl_pmd );

	SUBDBG( "SMPL.last_reset_val = %llu\n",

			( unsigned long long ) entry->last_reset_val );

	SUBDBG( "SMPL.ip = %#llx\n", ( unsigned long long ) entry->ip );

	SUBDBG( "SMPL.tstamp = %llu\n", ( unsigned long long ) entry->tstamp );

	SUBDBG( "SMPL.cpu = %d\n", entry->cpu );

	SUBDBG( "SMPL.set = %d\n", entry->set );

	SUBDBG( "SMPL.tgid = %d\n", entry->tgid );

}

#endif

#define PFM_MAX_PMCDS 20

int

_papi_pfm_write_pmcs( pfm_context_t * ctx, pfm_control_state_t * ctl )

{

	( void ) ctx;			 /*unused */

	unsigned int i = 0;

	int ret;

	SUBDBG( "PFM_WRITE_PMCS(%d,%p,%d)\n", ctl->ctx_fd, ctl->pc,

			ctl->out.pfp_pmc_count );

	if ( ctl->out.pfp_pmc_count > PFM_MAX_PMCDS ) {

		for ( i = 0; i < ctl->out.pfp_pmc_count - PFM_MAX_PMCDS;

			  i += PFM_MAX_PMCDS ) {

			if ( ( ret =

				   pfm_write_pmcs( ctl->ctx_fd, ctl->pc + i,

								   PFM_MAX_PMCDS ) ) ) {

				DEBUGCALL( DEBUG_SUBSTRATE, dump_pmc( ctl ) );

				PAPIERROR( "pfm_write_pmcs(%d,%p,%d): %s", ctl->ctx_fd, ctl->pc,

						   ctl->out.pfp_pmc_count, strerror( ret ) );

				return ( PAPI_ESYS );

			}

		}

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmc( ctl ) );

	}

	if ( ( ret =

		   pfm_write_pmcs( ctl->ctx_fd, ctl->pc + i,

						   ctl->out.pfp_pmc_count - i ) ) ) {

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmc( ctl ) );

		PAPIERROR( "pfm_write_pmcs(%d,%p,%d): %s", ctl->ctx_fd, ctl->pc,

				   ctl->out.pfp_pmc_count, strerror( ret ) );

		return ( PAPI_ESYS );

	}

	DEBUGCALL( DEBUG_SUBSTRATE, dump_pmc( ctl ) );

	return PAPI_OK;

}

int

_papi_pfm_write_pmds( pfm_context_t * ctx, pfm_control_state_t * ctl )

{

	( void ) ctx;			 /*unused */

	unsigned int i = 0;

	int ret;

	SUBDBG( "PFM_WRITE_PMDS(%d,%p,%d)\n", ctl->ctx_fd, ctl->pd,

			ctl->in.pfp_event_count );

	if ( ctl->in.pfp_event_count > PFM_MAX_PMCDS ) {

		for ( i = 0; i < ctl->in.pfp_event_count - PFM_MAX_PMCDS;

			  i += PFM_MAX_PMCDS ) {

			if ( ( ret =

				   pfm_write_pmds( ctl->ctx_fd, ctl->pd + i,

								   PFM_MAX_PMCDS ) ) ) {

				DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

				PAPIERROR( "pfm_write_pmds(%d,%p,%d): errno=%d %s", ctl->ctx_fd,

						   ctl->pd, ctl->in.pfp_event_count, errno,

						   strerror( ret ) );

				perror( "pfm_write_pmds" );

				return ( PAPI_ESYS );

			}

		}

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

	}

	if ( ( ret =

		   pfm_write_pmds( ctl->ctx_fd, ctl->pd + i,

						   ctl->in.pfp_event_count - i ) ) ) {

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

		PAPIERROR( "pfm_write_pmds(%d,%p,%d): errno=%d %s", ctl->ctx_fd,

				   ctl->pd, ctl->in.pfp_event_count, errno, strerror( ret ) );

		perror( "pfm_write_pmds" );

		return ( PAPI_ESYS );

	}

	DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

	return PAPI_OK;

}

int

_papi_pfm_read_pmds( pfm_context_t * ctx, pfm_control_state_t * ctl )

{

	( void ) ctx;			 /*unused */

	unsigned int i = 0;

	int ret;

	SUBDBG( "PFM_READ_PMDS(%d,%p,%d)\n", ctl->ctx_fd, ctl->pd,

			ctl->in.pfp_event_count );

	if ( ctl->in.pfp_event_count > PFM_MAX_PMCDS ) {

		for ( i = 0; i < ctl->in.pfp_event_count - PFM_MAX_PMCDS;

			  i += PFM_MAX_PMCDS ) {

			if ( ( ret =

				   pfm_read_pmds( ctl->ctx_fd, ctl->pd + i,

								  PFM_MAX_PMCDS ) ) ) {

				DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

				PAPIERROR( "pfm_read_pmds(%d,%p,%d): %s", ctl->ctx_fd, ctl->pd,

						   ctl->in.pfp_event_count, strerror( ret ) );

				return ( ( errno == EBADF ) ? PAPI_ECLOST : PAPI_ESYS );

			}

		}

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

	}

	if ( ( ret =

		   pfm_read_pmds( ctl->ctx_fd, ctl->pd + i,

						  ctl->in.pfp_event_count - i ) ) ) {

		DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

		PAPIERROR( "pfm_read_pmds(%d,%p,%d): %s", ctl->ctx_fd, ctl->pd,

				   ctl->in.pfp_event_count, strerror( ret ) );

		return ( ( errno == EBADF ) ? PAPI_ECLOST : PAPI_ESYS );

	}

	DEBUGCALL( DEBUG_SUBSTRATE, dump_pmd( ctl ) );

	return PAPI_OK;

}

/* This routine effectively does argument checking as the real magic will happen

   in compute_kernel_args. This just gets the value back from the kernel. */

static int

check_multiplex_timeout( int ctx_fd, unsigned long *timeout_ns )

{

	int ret;

	pfarg_setdesc_t set[2];

	memset( set, 0, sizeof ( pfarg_setdesc_t ) * 2 );

	set[1].set_id = 1;

	set[1].set_flags = PFM_SETFL_TIME_SWITCH;

	set[1].set_timeout = *timeout_ns;

	SUBDBG( "Multiplexing interval requested is %llu ns.\n",

			( unsigned long long ) set[1].set_timeout );

	/* Create a test eventset */

	SUBDBG( "PFM_CREATE_EVTSETS(%d,%p,1)\n", ctx_fd, &set[1] );

	if ( ( ret = pfm_create_evtsets( ctx_fd, &set[1], 1 ) ) != PFMLIB_SUCCESS ) {

		DEBUGCALL( DEBUG_SUBSTRATE, dump_sets( &set[1], 1 ) );

		PAPIERROR( "pfm_create_evtsets(%d,%p,%d): %s", ctx_fd, &set[1], 1,

				   strerror( ret ) );

		return ( PAPI_ESYS );

	}

	SUBDBG( "Multiplexing interval returned is %llu ns.\n",

			( unsigned long long ) set[1].set_timeout );

	*timeout_ns = set[1].set_timeout;

	/* Delete the second eventset */

	pfm_delete_evtsets( ctx_fd, &set[1], 1 );

	return ( PAPI_OK );

}

/* The below function is stolen from libpfm from Stephane Eranian */

static int

detect_timeout_and_unavail_pmu_regs( pfmlib_regmask_t * r_pmcs,

									 pfmlib_regmask_t * r_pmds,

									 unsigned long *timeout_ns )

{

	pfarg_ctx_t ctx;

	pfarg_setinfo_t setf;

	unsigned int i;

	int ret, j, myfd;

	memset( r_pmcs, 0, sizeof ( *r_pmcs ) );

	memset( r_pmds, 0, sizeof ( *r_pmds ) );

	memset( &ctx, 0, sizeof ( ctx ) );

	memset( &setf, 0, sizeof ( setf ) );

	/*

	 * if no context descriptor is passed, then create

	 * a temporary context

	 */

	SUBDBG( "PFM_CREATE_CONTEXT(%p,%p,%p,%d)\n", &ctx, NULL, NULL, 0 );

	myfd = pfm_create_context( &ctx, NULL, NULL, 0 );

	if ( myfd == -1 ) {

		PAPIERROR( "detect_unavail_pmu_regs:pfm_create_context(): %s",

				   strerror( errno ) );

		return ( PAPI_ESYS );

	}

	SUBDBG( "PFM_CREATE_CONTEXT returned fd %d\n", myfd );

	/*

	 * retrieve available register bitmasks from set0

	 * which is guaranteed to exist for every context

	 */

	ret = pfm_getinfo_evtsets( myfd, &setf, 1 );

	if ( ret != PFMLIB_SUCCESS ) {

		PAPIERROR( "pfm_getinfo_evtsets(): %s", strerror( ret ) );

		return ( PAPI_ESYS );

	}

	DEBUGCALL( DEBUG_SUBSTRATE, dump_setinfo( &setf, 1 ) );

	if ( r_pmcs )

		for ( i = 0; i < PFM_PMC_BV; i++ ) {

			for ( j = 0; j < 64; j++ ) {

				if ( ( setf.set_avail_pmcs[i] & ( 1ULL << j ) ) == 0 )

					pfm_regmask_set( r_pmcs, ( i << 6 ) + j );

			}

		}

	if ( r_pmds )

		for ( i = 0; i < PFM_PMD_BV; i++ ) {

			for ( j = 0; j < 64; j++ ) {

				if ( ( setf.set_avail_pmds[i] & ( 1ULL << j ) ) == 0 )

					pfm_regmask_set( r_pmds, ( i << 6 ) + j );

			}

		}

	check_multiplex_timeout( myfd, timeout_ns );

	i = close( myfd );

	SUBDBG( "CLOSE fd %d returned %d\n", myfd, i );

	return PAPI_OK;

}

/* BEGIN COMMON CODE */

static inline int

compute_kernel_args( hwd_control_state_t * ctl0 )

{

	pfm_control_state_t *ctl = ( pfm_control_state_t * ) ctl0;

	pfmlib_input_param_t *inp = &ctl->in;

	pfmlib_output_param_t *outp = &ctl->out;

	pfmlib_input_param_t tmpin;

	pfmlib_output_param_t tmpout;

#if 0

	/* This will be used to fixup the overflow and sample args after re-allocation */

	pfarg_pmd_t oldpd;

#endif

	pfarg_pmd_t *pd = ctl->pd;

	pfarg_pmc_t *pc = ctl->pc;

	pfarg_setdesc_t *sets = ctl->set;

	pfarg_setinfo_t *setinfos = ctl->setinfo;

	int *num_sets = &ctl->num_sets;

	unsigned int set = 0;

	int donepc = 0, donepd = 0, ret, j;

	unsigned int i, dispatch_count = inp->pfp_event_count;

	int togo = inp->pfp_event_count, done = 0;

	/* Save old PD array so we can reconstruct certain flags.  */

        /* This can be removed when we have higher level code call */

        /* set_profile,set_overflow etc when there is hardware     */

        /* (component) support, but this change won't happen for PAPI 3.5 */

	SUBDBG

		( "entry multiplexed %d, pfp_event_count %d, num_cntrs %d, num_sets %d\n",

		  ctl->multiplexed, inp->pfp_event_count, _perfmon2_vector.cmp_info.num_cntrs,

		  *num_sets );

	if ( ( ctl->multiplexed ) &&

		 ( inp->pfp_event_count >

		   ( unsigned int ) _perfmon2_vector.cmp_info.num_cntrs ) ) {

		dispatch_count = _perfmon2_vector.cmp_info.num_cntrs;

	}

	while ( togo ) {

	  again:

		memset( &tmpin, 0x0, sizeof ( tmpin ) );

		memset( &tmpout, 0x0, sizeof ( tmpout ) );

		SUBDBG( "togo %d, done %d, dispatch_count %d, num_cntrs %d\n", togo,

				done, dispatch_count, _perfmon2_vector.cmp_info.num_cntrs );

		tmpin.pfp_event_count = dispatch_count;

		tmpin.pfp_dfl_plm = inp->pfp_dfl_plm;

		/* Make sure we tell dispatch that these PMC's are not available */

		memcpy( &tmpin.pfp_unavail_pmcs, &_perfmon2_pfm_unavailable_pmcs,

				sizeof ( _perfmon2_pfm_unavailable_pmcs ) );

		for ( i = 0, j = done; i < dispatch_count; i++, j++ ) {

			memcpy( tmpin.pfp_events + i, inp->pfp_events + j,

					sizeof ( pfmlib_event_t ) );

		}

		if ( ( ret =

			   pfm_dispatch_events( &tmpin, NULL, &tmpout,

									NULL ) ) != PFMLIB_SUCCESS ) {

			if ( ctl->multiplexed ) {

				dispatch_count--;

				if ( dispatch_count == 0 ) {

					PAPIERROR( "pfm_dispatch_events(): %s",

							   pfm_strerror( ret ) );

					return ( _papi_libpfm_error( ret ) );

				}

				SUBDBG

					( "Dispatch failed because of counter conflict, trying again with %d counters.\n",

					  dispatch_count );

				goto again;

			}

			PAPIERROR( "pfm_dispatch_events(): %s", pfm_strerror( ret ) );

			return ( _papi_libpfm_error( ret ) );

		}

		/*

		 * Now prepare the argument to initialize the PMDs and PMCS.

		 * We must pfp_pmc_count to determine the number of PMC to intialize.

		 * We must use pfp_event_count to determine the number of PMD to initialize.

		 * Some events causes extra PMCs to be used, so  pfp_pmc_count may be >= pfp_event_count.

		 *

		 * This step is new compared to libpfm-2.x. It is necessary because the library no

		 * longer knows about the kernel data structures.

		 */

		for ( i = 0; i < tmpout.pfp_pmc_count; i++, donepc++ ) {

			pc[donepc].reg_num = tmpout.pfp_pmcs[i].reg_num;

			pc[donepc].reg_value = tmpout.pfp_pmcs[i].reg_value;

			pc[donepc].reg_set = set;

			SUBDBG( "PC%d (i%d) is reg num %d, value %llx, set %d\n", donepc, i,

					pc[donepc].reg_num,

					( unsigned long long ) pc[donepc].reg_value,

					pc[donepc].reg_set );

		}

		/* figure out pmd mapping from output pmc */

#if defined(HAVE_PFM_REG_EVT_IDX)

		for ( i = 0, j = 0; i < tmpin.pfp_event_count; i++, donepd++ ) {

			pd[donepd].reg_num = tmpout.pfp_pmcs[j].reg_pmd_num;

			pd[donepd].reg_set = set;

			SUBDBG( "PD%d (i%d,j%d) is reg num %d, set %d\n", donepd, i, j,

					pd[donepd].reg_num, pd[donepd].reg_set );

			/* Skip over entries that map to the same PMD, 

			   PIV has 2 PMCS for every PMD */

			for ( ; j < tmpout.pfp_pmc_count; j++ )

				if ( tmpout.pfp_pmcs[j].reg_evt_idx != i )

					break;

		}

#else

		for ( i = 0; i < tmpout.pfp_pmd_count; i++, donepd++ ) {

			pd[donepd].reg_num = tmpout.pfp_pmds[i].reg_num;

			pd[donepd].reg_set = set;

			SUBDBG( "PD%d (i%d) is reg num %d, set %d\n", donepd, i,

					pd[donepd].reg_num, pd[donepd].reg_set );

		}

#endif

		togo -= dispatch_count;

		done += dispatch_count;

		if ( togo > _perfmon2_vector.cmp_info.num_cntrs )

			dispatch_count = _perfmon2_vector.cmp_info.num_cntrs;

		else

			dispatch_count = togo;

		setinfos[set].set_id = set;

		sets[set].set_id = set;

		set++;

	}

	*num_sets = set;

	outp->pfp_pmc_count = donepc;

	if ( ctl->multiplexed && ( set > 1 ) ) {

		for ( i = 0; i < set; i++ ) {

			sets[i].set_flags = PFM_SETFL_TIME_SWITCH;

			sets[i].set_timeout = ctl->multiplexed;

		}

	}

	SUBDBG

		( "exit multiplexed %d (ns switch time), pfp_pmc_count %d, num_sets %d\n",

		  ctl->multiplexed, outp->pfp_pmc_count, *num_sets );

	return ( PAPI_OK );

}

int

tune_up_fd( int ctx_fd )

{

	int ret;

	/* set close-on-exec to ensure we will be getting the PFM_END_MSG, i.e.,

	 * fd not visible to child. */

	ret = fcntl( ctx_fd, F_SETFD, FD_CLOEXEC );

	if ( ret == -1 ) {

		PAPIERROR( "cannot fcntl(FD_CLOEXEC) on %d: %s", ctx_fd,

				   strerror( errno ) );

		return ( PAPI_ESYS );

	}

	/* setup asynchronous notification on the file descriptor */

	ret = fcntl( ctx_fd, F_SETFL, fcntl( ctx_fd, F_GETFL, 0 ) | O_ASYNC );

	if ( ret == -1 ) {

		PAPIERROR( "cannot fcntl(O_ASYNC) on %d: %s", ctx_fd,

				   strerror( errno ) );

		return ( PAPI_ESYS );

	}

	/* get ownership of the descriptor */

	ret = fcntl( ctx_fd, F_SETOWN, mygettid(  ) );

	if ( ret == -1 ) {

		PAPIERROR( "cannot fcntl(F_SETOWN) on %d: %s", ctx_fd,

				   strerror( errno ) );

		return ( PAPI_ESYS );

	}

	/*

	 * when you explicitely declare that you want a particular signal,

	 * even with you use the default signal, the kernel will send more

	 * information concerning the event to the signal handler.

	 *

	 * In particular, it will send the file descriptor from which the

	 * event is originating which can be quite useful when monitoring

	 * multiple tasks from a single thread.

	 */

	ret = fcntl( ctx_fd, F_SETSIG, _perfmon2_vector.cmp_info.hardware_intr_sig );

	if ( ret == -1 ) {

		PAPIERROR( "cannot fcntl(F_SETSIG,%d) on %d: %s",

				   _perfmon2_vector.cmp_info.hardware_intr_sig, ctx_fd,

				   strerror( errno ) );

		return ( PAPI_ESYS );

	}

	return ( PAPI_OK );

}

static int

attach( hwd_control_state_t * ctl, unsigned long tid )

{

	pfarg_ctx_t *newctx = ( pfarg_ctx_t * ) malloc( sizeof ( pfarg_ctx_t ) );

	pfarg_load_t *load_args =

		( pfarg_load_t * ) malloc( sizeof ( pfarg_load_t ) );

	int ret;

	if ( ( newctx == NULL ) || ( load_args == NULL ) )

		return ( PAPI_ENOMEM );

	memset( newctx, 0x0, sizeof ( *newctx ) );

	memset( load_args, 0, sizeof ( *load_args ) );

	/* Make sure the process exists and is being ptraced() */

	ret = ptrace( PTRACE_ATTACH, tid, NULL, NULL );

	if ( ret == 0 ) {

		ptrace( PTRACE_DETACH, tid, NULL, NULL );

		PAPIERROR( "Process/thread %d is not being ptraced", tid );

		free( newctx );

		free( load_args );

		return ( PAPI_EINVAL );

	}

	/* If we get here, then we should hope that the process is being

	   ptraced, if not, then we probably can't attach to it. */

	if ( ( ret == -1 ) && ( errno != EPERM ) ) {

		PAPIERROR( "Process/thread %d cannot be ptraced: %s", tid,

				   strerror( errno ) );

		free( newctx );

		free( load_args );

		return ( PAPI_EINVAL );

	}

	SUBDBG( "PFM_CREATE_CONTEXT(%p,%p,%p,%d)\n", newctx, NULL, NULL, 0 );

	if ( ( ret = pfm_create_context( newctx, NULL, NULL, 0 ) ) == -1 ) {

		PAPIERROR( "attach:pfm_create_context(): %s", strerror( errno ) );

		free( newctx );

		free( load_args );

		return ( PAPI_ESYS );

	}

	SUBDBG( "PFM_CREATE_CONTEXT returned fd %d\n", ret );

	tune_up_fd( ret );

	( ( pfm_control_state_t * ) ctl )->ctx_fd = ret;

	( ( pfm_control_state_t * ) ctl )->ctx = newctx;

	load_args->load_pid = tid;

	( ( pfm_control_state_t * ) ctl )->load = load_args;

	return ( PAPI_OK );

}

static int

detach( hwd_context_t * ctx, hwd_control_state_t * ctl )

{

	int i;

	i = close( ( ( pfm_control_state_t * ) ctl )->ctx_fd );

	SUBDBG( "CLOSE fd %d returned %d\n",

			( ( pfm_control_state_t * ) ctl )->ctx_fd, i );

	(void) i;

	/* Restore to main threads context */

	free( ( ( pfm_control_state_t * ) ctl )->ctx );

	( ( pfm_control_state_t * ) ctl )->ctx = &( ( pfm_context_t * ) ctx )->ctx;

	( ( pfm_control_state_t * ) ctl )->ctx_fd =

		( ( pfm_context_t * ) ctx )->ctx_fd;

	free( ( ( pfm_control_state_t * ) ctl )->load );

	( ( pfm_control_state_t * ) ctl )->load =

		&( ( pfm_context_t * ) ctx )->load;

	return ( PAPI_OK );

}

static inline int

set_domain( hwd_control_state_t * ctl0, int domain )

{

	pfm_control_state_t *ctl = ( pfm_control_state_t * ) ctl0;

	int mode = 0, did = 0;

	pfmlib_input_param_t *inp = &ctl->in;

	if ( domain & PAPI_DOM_USER ) {

		did = 1;

		mode |= PFM_PLM3;

	}

	if ( domain & PAPI_DOM_KERNEL ) {

		did = 1;

		mode |= PFM_PLM0;

	}

	if ( domain & PAPI_DOM_SUPERVISOR ) {

		did = 1;

		mode |= PFM_PLM1;

	}

	if ( domain & PAPI_DOM_OTHER ) {

		did = 1;

		mode |= PFM_PLM2;

	}

	if ( !did )

		return ( PAPI_EINVAL );

	inp->pfp_dfl_plm = mode;

	return ( compute_kernel_args( ctl ) );

}

static inline int

set_granularity( hwd_control_state_t * this_state, int domain )

{

	( void ) this_state;	 /*unused */

	switch ( domain ) {

	case PAPI_GRN_PROCG:

	case PAPI_GRN_SYS:

	case PAPI_GRN_SYS_CPU:

	case PAPI_GRN_PROC:

		return PAPI_ECMP;

	case PAPI_GRN_THR:

		break;

	default:

		return PAPI_EINVAL;

	}

	return PAPI_OK;

}

/* This function should tell your kernel extension that your children

   inherit performance register information and propagate the values up

   upon child exit and parent wait. */

static inline int

set_inherit( int arg )

{

	( void ) arg;			 /*unused */

	return PAPI_ECMP;

}

static int

get_string_from_file( char *file, char *str, int len )

{

	FILE *f = fopen( file, "r" );

	char buf[PAPI_HUGE_STR_LEN];

	if ( f == NULL ) {

		PAPIERROR( "fopen(%s): %s", file, strerror( errno ) );

		return ( PAPI_ESYS );

	}

	if ( fscanf( f, "%s\n", buf ) != 1 ) {

		PAPIERROR( "fscanf(%s, %%s\\n): Unable to scan 1 token", file );

		fclose( f );

		return PAPI_ESYS;

	}

	strncpy( str, buf, ( len > PAPI_HUGE_STR_LEN ? PAPI_HUGE_STR_LEN : len ) );

	fclose( f );

	return ( PAPI_OK );

}

int

_papi_pfm_init_component( int cidx )

{

   int retval;

   char buf[PAPI_HUGE_STR_LEN];

   /* The following checks the PFMLIB version 

      against the perfmon2 kernel version... */

   strncpy( _perfmon2_vector.cmp_info.support_version, buf,

	    sizeof ( _perfmon2_vector.cmp_info.support_version ) );

   retval = get_string_from_file( "/sys/kernel/perfmon/version",

			          _perfmon2_vector.cmp_info.kernel_version,

			sizeof ( _perfmon2_vector.cmp_info.kernel_version ) );

   if ( retval != PAPI_OK ) {

      strncpy(_perfmon2_vector.cmp_info.disabled_reason,

	     "/sys/kernel/perfmon/version not found",PAPI_MAX_STR_LEN);

      return retval;

   }

#ifdef PFM_VERSION

   sprintf( buf, "%d.%d", PFM_VERSION_MAJOR( PFM_VERSION ),

			  PFM_VERSION_MINOR( PFM_VERSION ) );

   SUBDBG( "Perfmon2 library versions...kernel: %s library: %s\n",

			_perfmon2_vector.cmp_info.kernel_version, buf );

   if ( strcmp( _perfmon2_vector.cmp_info.kernel_version, buf ) != 0 ) {

      /* do a little exception processing; 81 is compatible with 80 */

      if ( !( ( PFM_VERSION_MINOR( PFM_VERSION ) == 81 ) && 

            ( strncmp( _perfmon2_vector.cmp_info.kernel_version, "2.8", 3 ) ==

					 0 ) ) ) {

	 PAPIERROR( "Version mismatch of libpfm: compiled %s "

                    "vs. installed %s\n",

		    buf, _perfmon2_vector.cmp_info.kernel_version );

	 return PAPI_ESYS;

      }

   }

#endif

   _perfmon2_vector.cmp_info.hardware_intr_sig = SIGRTMIN + 2,

   /* Run the libpfm-specific setup */

   retval=_papi_libpfm_init(&_perfmon2_vector, cidx);

   if (retval) return retval;

   /* Load the module, find out if any PMC's/PMD's are off limits */

   /* Perfmon2 timeouts are based on the clock tick, we need to check

      them otherwise it will complain at us when we multiplex */

   unsigned long min_timeout_ns;

   struct timespec ts;

   if ( syscall( __NR_clock_getres, CLOCK_REALTIME, &ts ) == -1 ) {

      PAPIERROR( "Could not detect proper HZ rate, multiplexing may fail\n" );

      min_timeout_ns = 10000000;

   } else {

      min_timeout_ns = ts.tv_nsec;

   }

   /* This will fail if we've done timeout detection wrong */

   retval=detect_timeout_and_unavail_pmu_regs( &_perfmon2_pfm_unavailable_pmcs,

					       &_perfmon2_pfm_unavailable_pmds,

					       &min_timeout_ns );

   if ( retval != PAPI_OK ) {

      return ( retval );

   }	

   if ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_IBM ) {

      /* powerpc */

      _perfmon2_vector.cmp_info.available_domains |= PAPI_DOM_KERNEL | 

                                                     PAPI_DOM_SUPERVISOR;

      if (strcmp(_papi_hwi_system_info.hw_info.model_string, "POWER6" ) == 0) {

	 _perfmon2_vector.cmp_info.default_domain = PAPI_DOM_USER | 

	                                            PAPI_DOM_KERNEL | 

	                                            PAPI_DOM_SUPERVISOR;

      }

   } else {

      _perfmon2_vector.cmp_info.available_domains |= PAPI_DOM_KERNEL;

   }

   if ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_SUN ) {

      switch ( _perfmon2_pfm_pmu_type ) {

#ifdef PFMLIB_SPARC_ULTRA12_PMU

	     case PFMLIB_SPARC_ULTRA12_PMU:

	     case PFMLIB_SPARC_ULTRA3_PMU:

	     case PFMLIB_SPARC_ULTRA3I_PMU:

	     case PFMLIB_SPARC_ULTRA3PLUS_PMU:

	     case PFMLIB_SPARC_ULTRA4PLUS_PMU:

		  break;

#endif

	     default:

		   _perfmon2_vector.cmp_info.available_domains |= 

                                                      PAPI_DOM_SUPERVISOR;

		   break;

      }

   }

   if ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_CRAY ) {

      _perfmon2_vector.cmp_info.available_domains |= PAPI_DOM_OTHER;

   }

   if ( ( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_INTEL ) ||

	( _papi_hwi_system_info.hw_info.vendor == PAPI_VENDOR_AMD ) ) {

      _perfmon2_vector.cmp_info.fast_counter_read = 1;

      _perfmon2_vector.cmp_info.fast_real_timer = 1;

      _perfmon2_vector.cmp_info.cntr_umasks = 1;

   }

   return PAPI_OK;

}

int

_papi_pfm_shutdown_component(  )

{

	return PAPI_OK;

}

static int

_papi_pfm_init_thread( hwd_context_t * thr_ctx )

{

	pfarg_load_t load_args;

	pfarg_ctx_t newctx;

	int ret, ctx_fd;

#if defined(USE_PROC_PTTIMER)

	ret = init_proc_thread_timer( thr_ctx );

	if ( ret != PAPI_OK )

		return ( ret );

#endif