/*
* pfmlib_os_linux_v2.c: Perfmon2 syscall API
*
* Copyright (c) 2003-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 <stdint.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <syscall.h>
#include <perfmon/perfmon.h>
#include <perfmon/pfmlib.h>
#include "pfmlib_priv.h"
/*
* v2.x interface
*/
#define PFM_pfm_create_context (_pfmlib_get_sys_base()+0)
#define PFM_pfm_write_pmcs (_pfmlib_get_sys_base()+1)
#define PFM_pfm_write_pmds (_pfmlib_get_sys_base()+2)
#define PFM_pfm_read_pmds (_pfmlib_get_sys_base()+3)
#define PFM_pfm_load_context (_pfmlib_get_sys_base()+4)
#define PFM_pfm_start (_pfmlib_get_sys_base()+5)
#define PFM_pfm_stop (_pfmlib_get_sys_base()+6)
#define PFM_pfm_restart (_pfmlib_get_sys_base()+7)
#define PFM_pfm_create_evtsets (_pfmlib_get_sys_base()+8)
#define PFM_pfm_getinfo_evtsets (_pfmlib_get_sys_base()+9)
#define PFM_pfm_delete_evtsets (_pfmlib_get_sys_base()+10)
#define PFM_pfm_unload_context (_pfmlib_get_sys_base()+11)
/*
* argument to v2.2 pfm_create_context()
* ALWAYS use pfarg_ctx_t in programs, libpfm
* does convert ths structure on the fly if v2.2. is detected
*/
typedef struct {
unsigned char ctx_smpl_buf_id[16]; /* which buffer format to use */
uint32_t ctx_flags; /* noblock/block/syswide */
int32_t ctx_fd; /* ret arg: fd for context */
uint64_t ctx_smpl_buf_size; /* ret arg: actual buffer sz */
uint64_t ctx_reserved3[12]; /* for future use */
} pfarg_ctx22_t;
/*
* perfmon2 compatibility layer with perfmon3
*/
#ifndef PFMLIB_OLD_PFMV2
static int
pfm_create_context_2v3(pfarg_ctx_t *ctx, char *name, void *smpl_arg, size_t smpl_size)
{
pfarg_sinfo_t cinfo;
uint32_t fl;
/*
* simulate kernel returning error on NULL ctx
*/
if (!ctx) {
errno = EINVAL;
return -1;
}
/*
* if sampling format is used, then force SMPL_FMT
* and PFM_FL_SINFO because it comes first
*/
fl = ctx->ctx_flags;
if (name || smpl_arg || smpl_size)
fl |= PFM_FL_SMPL_FMT;
return pfm_create(fl, &cinfo, name, smpl_arg, smpl_size);
}
static int
pfm_write_pmcs_2v3(int fd, pfarg_pmc_t *pmcs, int count)
{
pfarg_pmr_t *pmrs;
int errno_save;
int i, ret;
size_t sz;
sz = count * sizeof(pfarg_pmr_t);
if (!pmcs)
return pfm_write(fd, 0, PFM_RW_PMC, NULL, sz);
pmrs = calloc(count, sizeof(*pmrs));
if (!pmrs) {
errno = ENOMEM;
return -1;
}
for (i=0 ; i < count; i++) {
pmrs[i].reg_num = pmcs[i].reg_num;
pmrs[i].reg_set = pmcs[i].reg_set;
pmrs[i].reg_flags = pmcs[i].reg_flags;
pmrs[i].reg_value = pmcs[i].reg_value;
}
ret = pfm_write(fd, 0, PFM_RW_PMC, pmrs, sz);
errno_save = errno;
free(pmrs);
errno = errno_save;
return ret;
}
static int
pfm_write_pmds_2v3(int fd, pfarg_pmd_t *pmds, int count)
{
pfarg_pmd_attr_t *pmas;
size_t sz;
int errno_save;
int i, ret;
sz = count * sizeof(*pmas);
if (!pmds)
return pfm_write(fd, 0, PFM_RW_PMD, NULL, sz);
pmas = calloc(count, sizeof(*pmas));
if (!pmas) {
errno = ENOMEM;
return -1;
}
for (i=0 ; i < count; i++) {
pmas[i].reg_num = pmds[i].reg_num;
pmas[i].reg_set = pmds[i].reg_set;
pmas[i].reg_flags = pmds[i].reg_flags;
pmas[i].reg_value = pmds[i].reg_value;
pmas[i].reg_long_reset = pmds[i].reg_long_reset;
pmas[i].reg_short_reset = pmds[i].reg_short_reset;
/* skip last_value not used on write */
pmas[i].reg_ovfl_swcnt = pmds[i].reg_ovfl_switch_cnt;
memcpy(pmas[i].reg_smpl_pmds, pmds[i].reg_smpl_pmds, sizeof(pmds[i].reg_smpl_pmds));
memcpy(pmas[i].reg_reset_pmds, pmds[i].reg_reset_pmds, sizeof(pmds[i].reg_reset_pmds));
pmas[i].reg_smpl_eventid = pmds[i].reg_smpl_eventid;
pmas[i].reg_random_mask = pmds[i].reg_random_mask;
}
ret = pfm_write(fd, 0, PFM_RW_PMD_ATTR, pmas, sz);
errno_save = errno;
free(pmas);
errno = errno_save;
return ret;
}
static int
pfm_read_pmds_2v3(int fd, pfarg_pmd_t *pmds, int count)
{
pfarg_pmd_attr_t *pmas;
int errno_save;
int i, ret;
size_t sz;
sz = count * sizeof(*pmas);
if (!pmds)
return pfm_write(fd, 0, PFM_RW_PMD, NULL, sz);
pmas = calloc(count, sizeof(*pmas));
if (!pmas) {
errno = ENOMEM;
return -1;
}
for (i=0 ; i < count; i++) {
pmas[i].reg_num = pmds[i].reg_num;
pmas[i].reg_set = pmds[i].reg_set;
pmas[i].reg_flags = pmds[i].reg_flags;
pmas[i].reg_value = pmds[i].reg_value;
}
ret = pfm_read(fd, 0, PFM_RW_PMD_ATTR, pmas, sz);
errno_save = errno;
for (i=0 ; i < count; i++) {
pmds[i].reg_value = pmas[i].reg_value;
pmds[i].reg_long_reset = pmas[i].reg_long_reset;
pmds[i].reg_short_reset = pmas[i].reg_short_reset;
pmds[i].reg_last_reset_val = pmas[i].reg_last_value;
pmds[i].reg_ovfl_switch_cnt = pmas[i].reg_ovfl_swcnt;
/* skip reg_smpl_pmds */
/* skip reg_reset_pmds */
/* skip reg_smpl_eventid */
/* skip reg_random_mask */
}
free(pmas);
errno = errno_save;
return ret;
}
static int
pfm_load_context_2v3(int fd, pfarg_load_t *load)
{
if (!load) {
errno = EINVAL;
return -1;
}
return pfm_attach(fd, 0, load->load_pid);
}
static int
pfm_start_2v3(int fd, pfarg_start_t *start)
{
if (start) {
__pfm_vbprintf("pfarg_start_t not supported in v3.x\n");
errno = EINVAL;
return -1;
}
return pfm_set_state(fd, 0, PFM_ST_START);
}
static int
pfm_stop_2v3(int fd)
{
return pfm_set_state(fd, 0, PFM_ST_STOP);
}
static int
pfm_restart_2v3(int fd)
{
return pfm_set_state(fd, 0, PFM_ST_RESTART);
}
static int
pfm_create_evtsets_2v3(int fd, pfarg_setdesc_t *setd, int count)
{
/* set_desc an setdesc are identical so we can cast */
return pfm_create_sets(fd, 0, (pfarg_set_desc_t *)setd, count * sizeof(pfarg_setdesc_t));
}
static int
pfm_delete_evtsets_2v3(int fd, pfarg_setdesc_t *setd, int count)
{
__pfm_vbprintf("pfm_delete_evtsets not supported in v3.x\n");
errno = EINVAL;
return -1;
}
static int
pfm_getinfo_evtsets_2v3(int fd, pfarg_setinfo_t *info, int count)
{
pfarg_sinfo_t cinfo;
pfarg_set_info_t *sif;
int fdx, i, ret, errno_save;
if (!info) {
errno = EFAULT;
return -1;
}
/*
* initialize bitmask to all available and defer checking
* until kernel. That means libpfm must be misled but we
* have no other way of fixing this
*/
memset(&cinfo, -1, sizeof(cinfo));
/*
* XXX: relies on the fact that cinfo is independent
* of the session type (which is wrong in the future)
*/
fdx = pfm_create(0, &cinfo);
if (fdx > -1)
close(fdx);
sif = calloc(count, sizeof(*sif));
if (!sif) {
errno = ENOMEM;
return -1;
}
for (i=0 ; i < count; i++)
sif[i].set_id = info[i].set_id;
ret = pfm_getinfo_sets(fd, 0, sif, count * sizeof(pfarg_set_info_t));
errno_save = errno;
if (ret)
goto skip;
for (i=0 ; i < count; i++) {
info[i].set_flags = 0;
memcpy(info[i].set_ovfl_pmds,
sif[i].set_ovfl_pmds,
sizeof(info[i].set_ovfl_pmds));
info[i].set_runs = sif[i].set_runs;
info[i].set_timeout = sif[i].set_timeout;
info[i].set_act_duration = sif[i].set_duration;
memcpy(info[i].set_avail_pmcs,
cinfo.sif_avail_pmcs,
sizeof(info[i].set_avail_pmcs));
memcpy(info[i].set_avail_pmds,
cinfo.sif_avail_pmds,
sizeof(info[i].set_avail_pmds));
}
skip:
free(sif);
errno = errno_save;
return ret;
}
static int
pfm_unload_context_2v3(int fd)
{
return pfm_attach(fd, 0, PFM_NO_TARGET);
}
#else /* PFMLIB_OLD_PFMV2 */
static int
pfm_create_context_2v3(pfarg_ctx_t *ctx, char *name, void *smpl_arg, size_t smpl_size)
{
return -1;
}
static int
pfm_write_pmcs_2v3(int fd, pfarg_pmc_t *pmcs, int count)
{
return -1;
}
static int
pfm_write_pmds_2v3(int fd, pfarg_pmd_t *pmds, int count)
{
return -1;
}
static int
pfm_read_pmds_2v3(int fd, pfarg_pmd_t *pmds, int count)
{
return -1;
}
static int
pfm_load_context_2v3(int fd, pfarg_load_t *load)
{
return -1;
}
static int
pfm_start_2v3(int fd, pfarg_start_t *start)
{
return -1;
}
static int
pfm_stop_2v3(int fd)
{
return -1;
}
static int
pfm_restart_2v3(int fd)
{
return -1;
}
static int
pfm_create_evtsets_2v3(int fd, pfarg_setdesc_t *setd, int count)
{
return -1;
}
static int
pfm_delete_evtsets_2v3(int fd, pfarg_setdesc_t *setd, int count)
{
return -1;
}
static int
pfm_getinfo_evtsets_2v3(int fd, pfarg_setinfo_t *info, int count)
{
return -1;
}
static int
pfm_unload_context_2v3(int fd)
{
return -1;
}
#endif /* PFMLIB_OLD_PFMV2 */
int
pfm_load_context(int fd, pfarg_load_t *load)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_load_context, fd, load);
return pfm_load_context_2v3(fd, load);
}
int
pfm_start(int fd, pfarg_start_t *start)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_start, fd, start);
return pfm_start_2v3(fd, start);
}
int
pfm_stop(int fd)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_stop, fd);
return pfm_stop_2v3(fd);
}
int
pfm_restart(int fd)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_restart, fd);
return pfm_restart_2v3(fd);
}
int
pfm_create_evtsets(int fd, pfarg_setdesc_t *setd, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_create_evtsets, fd, setd, count);
return pfm_create_evtsets_2v3(fd, setd, count);
}
int
pfm_delete_evtsets(int fd, pfarg_setdesc_t *setd, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_delete_evtsets, fd, setd, count);
return pfm_delete_evtsets_2v3(fd, setd, count);
}
int
pfm_getinfo_evtsets(int fd, pfarg_setinfo_t *info, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_getinfo_evtsets, fd, info, count);
return pfm_getinfo_evtsets_2v3(fd, info, count);
}
int
pfm_unload_context(int fd)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_unload_context, fd);
return pfm_unload_context_2v3(fd);
}
int
pfm_create_context(pfarg_ctx_t *ctx, char *name, void *smpl_arg, size_t smpl_size)
{
if (_pfmlib_major_version < 3) {
/*
* In perfmon v2.2, the pfm_create_context() call had a
* different return value. It used to return errno, in v2.3
* it returns the file descriptor.
*/
if (_pfmlib_minor_version < 3) {
int r;
pfarg_ctx22_t ctx22;
/* transfer the v2.3 contents to v2.2 for sys call */
memset (&ctx22, 0, sizeof(ctx22));
if (name != NULL) {
memcpy (ctx22.ctx_smpl_buf_id, name, 16);
}
ctx22.ctx_flags = ctx->ctx_flags;
/* ctx22.ctx_fd returned */
/* ctx22.ctx_smpl_buf_size returned */
memcpy (ctx22.ctx_reserved3, &ctx->ctx_reserved1, 64);
r = syscall (PFM_pfm_create_context, &ctx22, smpl_arg, smpl_size);
/* transfer the v2.2 contents back to v2.3 */
ctx->ctx_flags = ctx22.ctx_flags;
memcpy (&ctx->ctx_reserved1, ctx22.ctx_reserved3, 64);
return (r < 0 ? r : ctx22.ctx_fd);
} else {
return (int)syscall(PFM_pfm_create_context, ctx, name, smpl_arg, smpl_size);
}
}
return pfm_create_context_2v3(ctx, name, smpl_arg, smpl_size);
}
int
pfm_write_pmcs(int fd, pfarg_pmc_t *pmcs, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_write_pmcs, fd, pmcs, count);
return pfm_write_pmcs_2v3(fd, pmcs, count);
}
int
pfm_write_pmds(int fd, pfarg_pmd_t *pmds, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_write_pmds, fd, pmds, count);
return pfm_write_pmds_2v3(fd, pmds, count);
}
int
pfm_read_pmds(int fd, pfarg_pmd_t *pmds, int count)
{
if (_pfmlib_major_version < 3)
return (int)syscall(PFM_pfm_read_pmds, fd, pmds, count);
return pfm_read_pmds_2v3(fd, pmds, count);
}
#ifdef __ia64__
#define __PFMLIB_OS_COMPILE
#include <perfmon/pfmlib.h>
/*
* this is the old perfmon2 interface, maintained for backward
* compatibility reasons with older applications. This is for IA-64 ONLY.
*/
int
perfmonctl(int fd, int cmd, void *arg, int narg)
{
return syscall(__NR_perfmonctl, fd, cmd, arg, narg);
}
#endif /* __ia64__ */