#include <string.h>
/* Headers required by PAPI */
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"
#include "linux-coretemp.h"
/* this is what I found on my core2 machine
* but I have not explored this widely yet*/
#define REFRESH_LAT 4000
#define INVALID_RESULT -1000000L
papi_vector_t _coretemp_vector;
/* temporary event */
struct temp_event {
char name[PAPI_MAX_STR_LEN];
char units[PAPI_MIN_STR_LEN];
char description[PAPI_MAX_STR_LEN];
char location[PAPI_MAX_STR_LEN];
char path[PATH_MAX];
int stone;
long count;
struct temp_event *next;
};
static CORETEMP_native_event_entry_t * _coretemp_native_events;
static int num_events = 0;
static int is_initialized = 0;
/***************************************************************************/
/****** BEGIN FUNCTIONS USED INTERNALLY SPECIFIC TO THIS COMPONENT *******/
/***************************************************************************/
static struct temp_event* root = NULL;
static struct temp_event *last = NULL;
static int
insert_in_list(char *name, char *units,
char *description, char *filename) {
struct temp_event *temp;
/* new_event path, events->d_name */
temp = (struct temp_event *) papi_calloc(1, sizeof(struct temp_event));
if (temp==NULL) {
PAPIERROR("out of memory!");
/* We should also free any previously allocated data */
return PAPI_ENOMEM;
}
temp->next = NULL;
if (root == NULL) {
root = temp;
}
else if (last) {
last->next = temp;
}
else {
/* Because this is a function, it is possible */
/* we are called with root!=NULL but no last */
/* so add this to keep coverity happy */
free(temp);
PAPIERROR("This shouldn't be possible\n");
return PAPI_ECMP;
}
last = temp;
snprintf(temp->name, PAPI_MAX_STR_LEN, "%s", name);
snprintf(temp->units, PAPI_MIN_STR_LEN, "%s", units);
snprintf(temp->description, PAPI_MAX_STR_LEN, "%s", description);
snprintf(temp->path, PATH_MAX, "%s", filename);
return PAPI_OK;
}
/*
* find all coretemp information reported by the kernel
*/
static int
generateEventList(char *base_dir)
{
char path[PATH_MAX],filename[PATH_MAX];
char modulename[PAPI_MIN_STR_LEN],
location[PAPI_MIN_STR_LEN],
units[PAPI_MIN_STR_LEN],
description[PAPI_MAX_STR_LEN],
name[PAPI_MAX_STR_LEN];
DIR *dir,*d;
FILE *fff;
int count = 0;
struct dirent *hwmonx;
int i,pathnum;
#define NUM_PATHS 2
char paths[NUM_PATHS][PATH_MAX]={
"device","."
};
/* Open "/sys/class/hwmon" */
dir = opendir(base_dir);
if ( dir == NULL ) {
SUBDBG("Can't find %s, are you sure the coretemp module is loaded?\n",
base_dir);
return 0;
}
/* Iterate each /sys/class/hwmonX/device directory */
while( (hwmonx = readdir(dir) ) ) {
if ( !strncmp("hwmon", hwmonx->d_name, 5) ) {
/* Found a hwmon directory */
/* Sometimes the files are in ./, sometimes in device/ */
for(pathnum=0;pathnum<NUM_PATHS;pathnum++) {
snprintf(path, PATH_MAX, "%s/%s/%s",
base_dir, hwmonx->d_name,paths[pathnum]);
SUBDBG("Trying to open %s\n",path);
d = opendir(path);
if (d==NULL) {
continue;
}
/* Get the name of the module */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/name",path);
fff=fopen(filename,"r");
if (fff==NULL) {
snprintf(modulename, PAPI_MIN_STR_LEN, "Unknown");
} else {
if (fgets(modulename,PAPI_MIN_STR_LEN,fff)!=NULL) {
modulename[strlen(modulename)-1]='\0';
}
fclose(fff);
}
SUBDBG("Found module %s\n",modulename);
/******************************************************/
/* Try handling all events starting with in (voltage) */
/******************************************************/
/* arbitrary maximum */
/* the problem is the numbering can be sparse */
/* should probably go back to dirent listing */
for(i=0;i<32;i++) {
/* Try looking for a location label */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/in%d_label",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) {
strncpy(location,"?",PAPI_MIN_STR_LEN);
}
else {
if (fgets(location,PAPI_MIN_STR_LEN,fff)!=NULL) {
location[strlen(location)-1]='\0';
}
fclose(fff);
}
/* Look for input temperature */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/in%d_input",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) continue;
fclose(fff);
snprintf(name, PAPI_MAX_STR_LEN, "%s:in%i_input",
hwmonx->d_name, i);
snprintf(units, PAPI_MIN_STR_LEN, "V");
snprintf(description, PAPI_MAX_STR_LEN, "%s, %s module, label %s",
units,modulename,
location);
if (insert_in_list(name,units,description,filename)!=PAPI_OK) {
goto done_error;
}
count++;
}
/************************************************************/
/* Try handling all events starting with temp (temperature) */
/************************************************************/
for(i=0;i<32;i++) {
/* Try looking for a location label */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/temp%d_label",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) {
strncpy(location,"?",PAPI_MIN_STR_LEN);
}
else {
if (fgets(location,PAPI_MIN_STR_LEN,fff)!=NULL) {
location[strlen(location)-1]='\0';
}
fclose(fff);
}
/* Look for input temperature */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/temp%d_input",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) continue;
fclose(fff);
snprintf(name, PAPI_MAX_STR_LEN, "%s:temp%i_input",
hwmonx->d_name, i);
snprintf(units, PAPI_MIN_STR_LEN, "degrees C");
snprintf(description, PAPI_MAX_STR_LEN, "%s, %s module, label %s",
units,modulename,
location);
if (insert_in_list(name,units,description,filename)!=PAPI_OK) {
goto done_error;
}
count++;
}
/************************************************************/
/* Try handling all events starting with fan (fan) */
/************************************************************/
for(i=0;i<32;i++) {
/* Try looking for a location label */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/fan%d_label",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) {
strncpy(location,"?",PAPI_MIN_STR_LEN);
}
else {
if (fgets(location,PAPI_MIN_STR_LEN,fff)!=NULL) {
location[strlen(location)-1]='\0';
}
fclose(fff);
}
/* Look for input fan */
snprintf(filename, PAPI_MAX_STR_LEN, "%s/fan%d_input",
path,i);
fff=fopen(filename,"r");
if (fff==NULL) continue;
fclose(fff);
snprintf(name, PAPI_MAX_STR_LEN, "%s:fan%i_input",
hwmonx->d_name, i);
snprintf(units, PAPI_MIN_STR_LEN, "RPM");
snprintf(description, PAPI_MAX_STR_LEN, "%s, %s module, label %s",
units,modulename,
location);
if (insert_in_list(name,units,description,filename)!=PAPI_OK) {
goto done_error;
}
count++;
}
closedir(d);
}
}
}
closedir(dir);
return count;
done_error:
closedir(d);
closedir(dir);
return PAPI_ECMP;
}
static long long
getEventValue( int index )
{
char buf[PAPI_MAX_STR_LEN];
FILE* fp;
long result;
if (_coretemp_native_events[index].stone) {
return _coretemp_native_events[index].value;
}
fp = fopen(_coretemp_native_events[index].path, "r");
if (fp==NULL) {
return INVALID_RESULT;
}
if (fgets(buf, PAPI_MAX_STR_LEN, fp)==NULL) {
result=INVALID_RESULT;
}
else {
result=strtoll(buf, NULL, 10);
}
fclose(fp);
return result;
}
/*****************************************************************************
******************* BEGIN PAPI's COMPONENT REQUIRED FUNCTIONS *************
*****************************************************************************/
/*
* This is called whenever a thread is initialized
*/
static int
_coretemp_init_thread( hwd_context_t *ctx )
{
( void ) ctx;
return PAPI_OK;
}
/* Initialize hardware counters, setup the function vector table
* and get hardware information, this routine is called when the
* PAPI process is initialized (IE PAPI_library_init)
*/
static int
_coretemp_init_component( int cidx )
{
int i = 0;
struct temp_event *t,*last;
if ( is_initialized )
return (PAPI_OK );
is_initialized = 1;
/* This is the prefered method, all coretemp sensors are symlinked here
* see $(kernel_src)/Documentation/hwmon/sysfs-interface */
num_events = generateEventList("/sys/class/hwmon");
if ( num_events < 0 ) {
strncpy(_coretemp_vector.cmp_info.disabled_reason,
"Cannot open /sys/class/hwmon",PAPI_MAX_STR_LEN);
return PAPI_ENOCMP;
}
if ( num_events == 0 ) {
strncpy(_coretemp_vector.cmp_info.disabled_reason,
"No coretemp events found",PAPI_MAX_STR_LEN);
return PAPI_ENOCMP;
}
t = root;
_coretemp_native_events = (CORETEMP_native_event_entry_t*)
papi_calloc(num_events, sizeof(CORETEMP_native_event_entry_t));
do {
strncpy(_coretemp_native_events[i].name,t->name,PAPI_MAX_STR_LEN);
_coretemp_native_events[i].name[PAPI_MAX_STR_LEN-1] = '\0';
strncpy(_coretemp_native_events[i].path,t->path,PATH_MAX);
_coretemp_native_events[i].path[PATH_MAX-1] = '\0';
strncpy(_coretemp_native_events[i].units,t->units,PAPI_MIN_STR_LEN);
_coretemp_native_events[i].units[PAPI_MIN_STR_LEN-1] = '\0';
strncpy(_coretemp_native_events[i].description,t->description,PAPI_MAX_STR_LEN);
_coretemp_native_events[i].description[PAPI_MAX_STR_LEN-1] = '\0';
_coretemp_native_events[i].stone = 0;
_coretemp_native_events[i].resources.selector = i + 1;
last = t;
t = t->next;
papi_free(last);
i++;
} while (t != NULL);
root = NULL;
/* Export the total number of events available */
_coretemp_vector.cmp_info.num_native_events = num_events;
/* Export the component id */
_coretemp_vector.cmp_info.CmpIdx = cidx;
return PAPI_OK;
}
/*
* Control of counters (Reading/Writing/Starting/Stopping/Setup)
* functions
*/
static int
_coretemp_init_control_state( hwd_control_state_t * ctl)
{
int i;
CORETEMP_control_state_t *coretemp_ctl = (CORETEMP_control_state_t *) ctl;
for ( i=0; i < num_events; i++ ) {
coretemp_ctl->counts[i] = getEventValue(i);
}
/* Set last access time for caching results */
coretemp_ctl->lastupdate = PAPI_get_real_usec();
return PAPI_OK;
}
static int
_coretemp_start( hwd_context_t *ctx, hwd_control_state_t *ctl)
{
( void ) ctx;
( void ) ctl;
return PAPI_OK;
}
static int
_coretemp_read( hwd_context_t *ctx, hwd_control_state_t *ctl,
long long ** events, int flags)
{
(void) flags;
(void) ctx;
CORETEMP_control_state_t* control = (CORETEMP_control_state_t*) ctl;
long long now = PAPI_get_real_usec();
int i;
/* Only read the values from the kernel if enough time has passed */
/* since the last read. Otherwise return cached values. */
if ( now - control->lastupdate > REFRESH_LAT ) {
for ( i = 0; i < num_events; i++ ) {
control->counts[i] = getEventValue( i );
}
control->lastupdate = now;
}
/* Pass back a pointer to our results */
*events = control->counts;
return PAPI_OK;
}
static int
_coretemp_stop( hwd_context_t *ctx, hwd_control_state_t *ctl )
{
(void) ctx;
/* read values */
CORETEMP_control_state_t* control = (CORETEMP_control_state_t*) ctl;
int i;
for ( i = 0; i < num_events; i++ ) {
control->counts[i] = getEventValue( i );
}
return PAPI_OK;
}
/* Shutdown a thread */
static int
_coretemp_shutdown_thread( hwd_context_t * ctx )
{
( void ) ctx;
return PAPI_OK;
}
/*
* Clean up what was setup in coretemp_init_component().
*/
static int
_coretemp_shutdown_component( )
{
if ( is_initialized ) {
is_initialized = 0;
papi_free(_coretemp_native_events);
_coretemp_native_events = NULL;
}
return PAPI_OK;
}
/* This function sets various options in the component
* The valid codes being passed in are PAPI_SET_DEFDOM,
* PAPI_SET_DOMAIN, PAPI_SETDEFGRN, PAPI_SET_GRANUL * and PAPI_SET_INHERIT
*/
static int
_coretemp_ctl( hwd_context_t *ctx, int code, _papi_int_option_t *option )
{
( void ) ctx;
( void ) code;
( void ) option;
return PAPI_OK;
}
static int
_coretemp_update_control_state( hwd_control_state_t *ptr,
NativeInfo_t * native, int count,
hwd_context_t * ctx )
{
int i, index;
( void ) ctx;
( void ) ptr;
for ( i = 0; i < count; i++ ) {
index = native[i].ni_event;
native[i].ni_position = _coretemp_native_events[index].resources.selector - 1;
}
return PAPI_OK;
}
/*
* This function has to set the bits needed to count different domains
* In particular: PAPI_DOM_USER, PAPI_DOM_KERNEL PAPI_DOM_OTHER
* By default return PAPI_EINVAL if none of those are specified
* and PAPI_OK with success
* PAPI_DOM_USER is only user context is counted
* PAPI_DOM_KERNEL is only the Kernel/OS context is counted
* PAPI_DOM_OTHER is Exception/transient mode (like user TLB misses)
* PAPI_DOM_ALL is all of the domains
*/
static int
_coretemp_set_domain( hwd_control_state_t * cntl, int domain )
{
(void) cntl;
if ( PAPI_DOM_ALL != domain )
return PAPI_EINVAL;
return PAPI_OK;
}
static int
_coretemp_reset( hwd_context_t *ctx, hwd_control_state_t *ctl )
{
( void ) ctx;
( void ) ctl;
return PAPI_OK;
}
/*
* Native Event functions
*/
static int
_coretemp_ntv_enum_events( unsigned int *EventCode, int modifier )
{
int index;
switch ( modifier ) {
case PAPI_ENUM_FIRST:
if (num_events==0) {
return PAPI_ENOEVNT;
}
*EventCode = 0;
return PAPI_OK;
case PAPI_ENUM_EVENTS:
index = *EventCode;
if ( index < num_events - 1 ) {
*EventCode = *EventCode + 1;
return PAPI_OK;
} else {
return PAPI_ENOEVNT;
}
break;
default:
return PAPI_EINVAL;
}
return PAPI_EINVAL;
}
/*
*
*/
static int
_coretemp_ntv_code_to_name( unsigned int EventCode, char *name, int len )
{
int index = EventCode;
if ( index >= 0 && index < num_events ) {
strncpy( name, _coretemp_native_events[index].name, len );
return PAPI_OK;
}
return PAPI_ENOEVNT;
}
/*
*
*/
static int
_coretemp_ntv_code_to_descr( unsigned int EventCode, char *name, int len )
{
int index = EventCode;
if ( index >= 0 && index < num_events ) {
strncpy( name, _coretemp_native_events[index].description, len );
return PAPI_OK;
}
return PAPI_ENOEVNT;
}
static int
_coretemp_ntv_code_to_info(unsigned int EventCode, PAPI_event_info_t *info)
{
int index = EventCode;
if ( ( index < 0) || (index >= num_events )) return PAPI_ENOEVNT;
strncpy( info->symbol, _coretemp_native_events[index].name, sizeof(info->symbol));
strncpy( info->long_descr, _coretemp_native_events[index].description, sizeof(info->long_descr));
strncpy( info->units, _coretemp_native_events[index].units, sizeof(info->units));
info->units[sizeof(info->units)-1] = '\0';
return PAPI_OK;
}
/*
*
*/
papi_vector_t _coretemp_vector = {
.cmp_info = {
/* default component information (unspecified values are initialized to 0) */
.name = "coretemp",
.short_name = "coretemp",
.description = "Linux hwmon temperature and other info",
.version = "4.2.1",
.num_mpx_cntrs = CORETEMP_MAX_COUNTERS,
.num_cntrs = CORETEMP_MAX_COUNTERS,
.default_domain = PAPI_DOM_ALL,
.available_domains = PAPI_DOM_ALL,
.default_granularity = PAPI_GRN_SYS,
.available_granularities = PAPI_GRN_SYS,
.hardware_intr_sig = PAPI_INT_SIGNAL,
/* component specific cmp_info initializations */
.fast_real_timer = 0,
.fast_virtual_timer = 0,
.attach = 0,
.attach_must_ptrace = 0,
}
,
/* sizes of framework-opaque component-private structures */
.size = {
.context = sizeof ( CORETEMP_context_t ),
.control_state = sizeof ( CORETEMP_control_state_t ),
.reg_value = sizeof ( CORETEMP_register_t ),
.reg_alloc = sizeof ( CORETEMP_reg_alloc_t ),
}
,
/* function pointers in this component */
.init_thread = _coretemp_init_thread,
.init_component = _coretemp_init_component,
.init_control_state = _coretemp_init_control_state,
.start = _coretemp_start,
.stop = _coretemp_stop,
.read = _coretemp_read,
.shutdown_thread = _coretemp_shutdown_thread,
.shutdown_component = _coretemp_shutdown_component,
.ctl = _coretemp_ctl,
.update_control_state = _coretemp_update_control_state,
.set_domain = _coretemp_set_domain,
.reset = _coretemp_reset,
.ntv_enum_events = _coretemp_ntv_enum_events,
.ntv_code_to_name = _coretemp_ntv_code_to_name,
.ntv_code_to_descr = _coretemp_ntv_code_to_descr,
.ntv_code_to_info = _coretemp_ntv_code_to_info,
};