linux-lmsensors.c File Reference

This file has the source code for a component that enables PAPI-C to access hardware monitoring sensors through the libsensors library. This code will dynamically create a native events table for all the sensors that can be accesed by the libsensors library. In order to learn more about libsensors, visit: (http://www.lm-sensors.org) More...

Include dependency graph for linux-lmsensors.c:

Go to the source code of this file.

Data Structures
struct	_lmsensors_register_t
struct	_lmsensors_native_event_entry_t
struct	_lmsensors_reg_alloc_t
struct	_lmsensors_control_state_t
struct	_lmsensors_context_t

Macros
#define	LM_SENSORS_REFRESHTIME   200000

Functions
static unsigned	createNativeEvents (void)
static long_long	getEventValue (unsigned event_id)
static int	_lmsensors_init_thread (hwd_context_t *ctx)
static int	_lmsensors_init_component (int cidx)
static int	link_lmsensors_libraries ()
static int	_lmsensors_init_control_state (hwd_control_state_t *ctl)
static int	_lmsensors_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_lmsensors_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_lmsensors_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long_long **events, int flags)
static int	_lmsensors_shutdown_component (void)
static int	_lmsensors_shutdown_thread (hwd_context_t *ctx)
static int	_lmsensors_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_lmsensors_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_lmsensors_set_domain (hwd_control_state_t *ctl, int domain)
static int	_lmsensors_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_lmsensors_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_lmsensors_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_lmsensors_ntv_code_to_descr (unsigned int EventCode, char *name, int len)

Variables
static _lmsensors_native_event_entry_t *	lm_sensors_native_table
static int	num_events = 0
static long_long *	cached_counts = NULL
static int(*	sensors_initPtr )(FILE *input)
static void(*	sensors_cleanupPtr )(void)
static int(*	sensors_snprintf_chip_namePtr )(char *str, size_t size, const sensors_chip_name *chip)
static char *(*	sensors_get_labelPtr )(const sensors_chip_name *name, const sensors_feature *feature)
static int(*	sensors_get_valuePtr )(const sensors_chip_name *name, int subfeat_nr, double *value)
static const sensors_chip_name *(*	sensors_get_detected_chipsPtr )(const sensors_chip_name *match, int *nr)
static const sensors_feature *(*	sensors_get_featuresPtr )(const sensors_chip_name *name, int *nr)
static const sensors_subfeature *(*	sensors_get_all_subfeaturesPtr )(const sensors_chip_name *name, const sensors_feature *feature, int *nr)
static void *	dl1 = NULL
static char	lmsensors_main [] =PAPI_LMSENSORS_MAIN
void(*	_dl_non_dynamic_init )(void)
papi_vector_t	_lmsensors_vector

Detailed Description

Author

Daniel Lucio

Joachim Protze

Heike Jagode jagod.nosp@m.e@ee.nosp@m.cs.ut.nosp@m.k.ed.nosp@m.u

LM_SENSORS component

Tested version of lm_sensors: 3.1.1

Notes:

• I used the ACPI and MX components to write this component. A lot of the code in this file mimics what other components already do.
• The return values are scaled by 1000 because PAPI can not return decimals.
• A call of PAPI_read can take up to 2 seconds while using lm_sensors!
• Please remember that libsensors uses the GPL license.

Definition in file linux-lmsensors.c.

Macro Definition Documentation

LM_SENSORS_REFRESHTIME

#define LM_SENSORS_REFRESHTIME   200000

Definition at line 47 of file linux-lmsensors.c.

Function Documentation

_lmsensors_ctl()

static int _lmsensors_ctl ( hwd_context_t *  ctx, int  code, _papi_int_option_t *  option  )

static

Definition at line 581 of file linux-lmsensors.c.

{
    ( void ) ctx;
    ( void ) code;
    ( void ) option;
    return PAPI_OK;
}

_lmsensors_init_component()

static int _lmsensors_init_component ( int  cidx )

static

Definition at line 292 of file linux-lmsensors.c.

{
    int res;
    (void) cidx;
 
    /* link in all the lmsensor libraries and resolve the symbols we need to use */
    if (link_lmsensors_libraries() != PAPI_OK) {
        SUBDBG ("Dynamic link of lmsensors libraries failed, component will be disabled.\n");
        SUBDBG ("See disable reason in papi_component_avail output for more details.\n");
        res = PAPI_ENOSUPP;
        goto fn_fail;
    }
 
    /* Initialize libsensors library */
    if ( ( res = sensors_initPtr( NULL ) ) != 0 ) {
       strncpy(_lmsensors_vector.cmp_info.disabled_reason,
          "Cannot enable libsensors",PAPI_MAX_STR_LEN);
       goto fn_fail;
    }
 
    /* Create dyanmic events table */
    num_events = detectSensors(  );
    SUBDBG("Found %d sensors\n",num_events);
 
    _lmsensors_vector.cmp_info.num_mpx_cntrs = num_events;
    _lmsensors_vector.cmp_info.num_cntrs = num_events;
 
    if ( ( lm_sensors_native_table =
       calloc( num_events, sizeof ( _lmsensors_native_event_entry_t )))
                   == NULL ) {
       strncpy(_lmsensors_vector.cmp_info.disabled_reason,
          "Could not malloc room",PAPI_MAX_STR_LEN);
       res = PAPI_ENOMEM;
       goto fn_fail;
    }
 
    cached_counts = (long long*) calloc(num_events, sizeof(long long));
 
    if (cached_counts == NULL) {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
               "Could not malloc room",PAPI_MAX_STR_LEN);
      free(lm_sensors_native_table);
      lm_sensors_native_table = NULL;
      res = PAPI_ENOMEM;
      goto fn_fail;
    }
 
    if ( ( unsigned ) num_events != createNativeEvents(  ) ) {
       strncpy(_lmsensors_vector.cmp_info.disabled_reason,
          "LM_SENSOR number mismatch",PAPI_MAX_STR_LEN);
      free(cached_counts);
      cached_counts = NULL;
      free(lm_sensors_native_table);
      lm_sensors_native_table = NULL;
      res = PAPI_ECMP;
      goto fn_fail;
    }
 
    _lmsensors_vector.cmp_info.num_native_events=num_events;
    _lmsensors_vector.cmp_info.num_cntrs=num_events;
 
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = res;
    return res;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

_lmsensors_init_control_state()

static int _lmsensors_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 481 of file linux-lmsensors.c.

{
    int i;
 
    for ( i = 0; i < num_events; i++ )
        cached_counts[i] = getEventValue( i );
 
    ( ( _lmsensors_control_state_t * ) ctl )->lastupdate =
        PAPI_get_real_usec(  );
    return PAPI_OK;
}

Here is the call graph for this function:

_lmsensors_init_thread()

static int _lmsensors_init_thread ( hwd_context_t *  ctx )

static

Definition at line 280 of file linux-lmsensors.c.

{
    ( void ) ctx;
    return PAPI_OK;
}

_lmsensors_ntv_code_to_descr()

static int _lmsensors_ntv_code_to_descr ( unsigned int  EventCode, char *  name, int  len  )

static

Definition at line 686 of file linux-lmsensors.c.

{
    int index = EventCode;
 
    if (index>=0 && index<num_events) {
       strncpy( name, lm_sensors_native_table[index].description, len );
    }
    return PAPI_OK;
}

_lmsensors_ntv_code_to_name()

static int _lmsensors_ntv_code_to_name ( unsigned int  EventCode, char *  name, int  len  )

static

Definition at line 671 of file linux-lmsensors.c.

{
    int index = EventCode;
 
    if (index>=0 && index<num_events) {
       strncpy( name, lm_sensors_native_table[index].name, len );
    }
 
    return PAPI_OK;
}

_lmsensors_ntv_enum_events()

static int _lmsensors_ntv_enum_events ( unsigned int *  EventCode, int  modifier  )

static

Definition at line 639 of file linux-lmsensors.c.

{
 
    switch ( modifier ) {
    case PAPI_ENUM_FIRST:
        *EventCode = 0;
 
        return PAPI_OK;
        break;
 
    case PAPI_ENUM_EVENTS:
    {
        int 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;
}

_lmsensors_read()

static int _lmsensors_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long_long **  events, int  flags  )

static

Definition at line 524 of file linux-lmsensors.c.

{
    ( void ) ctx;
    ( void ) flags;
    long long start = PAPI_get_real_usec(  );
    int i;
 
    _lmsensors_control_state_t *control=(_lmsensors_control_state_t *)ctl;
 
    if ( start - control->lastupdate > 200000 ) {   // cache refresh
       
       for ( i = 0; i < num_events; i++ ) {
       cached_counts[i] = getEventValue( i );
       }
       control->lastupdate = PAPI_get_real_usec(  );
    }
 
    *events = cached_counts;
    return PAPI_OK;
}

Here is the call graph for this function:

_lmsensors_reset()

static int _lmsensors_reset ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 627 of file linux-lmsensors.c.

{
    ( void ) ctx;
    ( void ) ctl;
    return PAPI_OK;
}

_lmsensors_set_domain()

static int _lmsensors_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 613 of file linux-lmsensors.c.

{
    (void) ctl;
    if ( PAPI_DOM_ALL != domain )
        return ( PAPI_EINVAL );
 
    return ( PAPI_OK );
}

_lmsensors_shutdown_component()

static int _lmsensors_shutdown_component ( void  )

static

Definition at line 548 of file linux-lmsensors.c.

{
    if (cached_counts)   {
        free(cached_counts);
      cached_counts = NULL;
   }
 
    /* Call the libsensors cleaning function before leaving */
    sensors_cleanupPtr(  );
 
   if (lm_sensors_native_table) {
      free(lm_sensors_native_table);
      lm_sensors_native_table = NULL;
   }
 
    return PAPI_OK;
}

_lmsensors_shutdown_thread()

static int _lmsensors_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 567 of file linux-lmsensors.c.

{
    ( void ) ctx;
 
    return PAPI_OK;
}

_lmsensors_start()

static int _lmsensors_start ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 498 of file linux-lmsensors.c.

{
    ( void ) ctx;
    ( void ) ctl;
 
    return PAPI_OK;
}

_lmsensors_stop()

static int _lmsensors_stop ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 511 of file linux-lmsensors.c.

{
    ( void ) ctx;
    ( void ) ctl;
 
    return PAPI_OK;
}

_lmsensors_update_control_state()

static int _lmsensors_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  native, int  count, hwd_context_t *  ctx  )

static

Definition at line 591 of file linux-lmsensors.c.

{
    int i, index;
    ( void ) ctx;
    ( void ) ctl;
 
    for ( i = 0; i < count; i++ ) {
    index = native[i].ni_event;
    native[i].ni_position =
            lm_sensors_native_table[index].resources.selector - 1;
    }
    return PAPI_OK;
}

createNativeEvents()

static unsigned createNativeEvents ( void  )

static

Definition at line 171 of file linux-lmsensors.c.

{
    unsigned id = 0;
    int chip_nr = 0;
    const sensors_chip_name *chip_name;
 
    /* component name and description */
    strcpy( _lmsensors_vector.cmp_info.short_name, "lmsensors" );
    strcpy( _lmsensors_vector.cmp_info.description,
            "lm-sensors provides tools for monitoring the hardware health" );
 
 
    /* Loop through all the chips found */
    while ( ( chip_name =
              sensors_get_detected_chipsPtr( NULL, &chip_nr ) ) != NULL ) {
       int a, b;
       const sensors_feature *feature;
       const sensors_subfeature *sub;
       char chipnamestring[PAPI_MIN_STR_LEN];
 
       //      lm_sensors_native_table[id].count = 0;
 
        /* get chip name from its internal representation */
       sensors_snprintf_chip_namePtr( chipnamestring,
                        PAPI_MIN_STR_LEN, chip_name );
 
       a = 0;
 
       /* Loop through all the features found */
       while ( ( feature = sensors_get_featuresPtr( chip_name, &a ) ) ) {
          char *featurelabel;
 
          if ( !( featurelabel = sensors_get_labelPtr( chip_name, feature ))) {
         fprintf( stderr, "ERROR: Can't get label of feature %s!\n",
                         feature->name );
         continue;
          }
 
          b = 0;
 
          /* Loop through all the subfeatures found */
          while ((sub=sensors_get_all_subfeaturesPtr(chip_name,feature,&b))) {
 
         /* replace spaces with underscores */
         char *ptr;
         while( (ptr = strchr(featurelabel, ' ')) != NULL ){ *ptr = '_'; }
 
         /* Save native event data */
         sprintf( lm_sensors_native_table[id].name, "%s.%s.%s",
              chipnamestring, featurelabel, sub->name );
 
         strncpy( lm_sensors_native_table[id].description,
              lm_sensors_native_table[id].name, PAPI_MAX_STR_LEN );
                 lm_sensors_native_table[id].description[PAPI_MAX_STR_LEN-1] = '\0';
 
         /* The selector has to be !=0 . Starts with 1 */
         lm_sensors_native_table[id].resources.selector = id + 1;
 
         /* Save the actual references to this event */
         lm_sensors_native_table[id].resources.name = chip_name;
         lm_sensors_native_table[id].resources.subfeat_nr = sub->number;
 
         /* increment the table index counter */
         id++;       
          }
 
          //   lm_sensors_native_table[id].count = count + 1;
          free( featurelabel );
       }
    }
 
    /* Return the number of events created */
    return id;
}

Here is the caller graph for this function:

getEventValue()

static long_long getEventValue ( unsigned  event_id )

static

Definition at line 253 of file linux-lmsensors.c.

{
    double value;
    int res;
 
    res = sensors_get_valuePtr( lm_sensors_native_table[event_id].resources.name,
                             lm_sensors_native_table[event_id].resources.
                             subfeat_nr, &value );
 
    if ( res < 0 ) {
        fprintf( stderr, "libsensors(): Could not read event #%d!\n",
                 event_id );
        return -1;
    }
 
    return ( ( long_long ) ( value * 1000 ) );
}

Here is the caller graph for this function:

link_lmsensors_libraries()

static int link_lmsensors_libraries ( )

static

Definition at line 369 of file linux-lmsensors.c.

{
   if ( _dl_non_dynamic_init != NULL ) {
      // If weak var present, statically linked insted of dynamic.
      strncpy( _lmsensors_vector.cmp_info.disabled_reason, "The lmsensors component REQUIRES dynamic linking capabilities.", PAPI_MAX_STR_LEN-1);
      // EXIT not supported.
      return PAPI_ENOSUPP;
   }
 
   char path_name[1024];
   char *lmsensors_root = getenv("PAPI_LMSENSORS_ROOT"); 
   
   dl1 = NULL;
   // Step 1: Process override if given.   
   if (strlen(lmsensors_main) > 0) {                                  // If override given, it has to work.
      dl1 = dlopen(lmsensors_main, RTLD_NOW | RTLD_GLOBAL);           // Try to open that path.
      if (dl1 == NULL) {
         snprintf(_lmsensors_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN, "PAPI_LMSENSORS_MAIN override '%s' given in Rules.lmsensors not found.", lmsensors_main);
         return(PAPI_ENOSUPP);   // Override given but not found.
      }
   }
 
   // Step 2: Try system paths, will work with Spack, LD_LIBRARY_PATH, default paths.
   if (dl1 == NULL) {                                           // No override,
      dl1 = dlopen("libsensors.so", RTLD_NOW | RTLD_GLOBAL);        // Try system paths.
   }
 
   // Step 3: Try the explicit install default. 
   if (dl1 == NULL && lmsensors_root != NULL) {                          // if root given, try it.
      snprintf(path_name, PATH_MAX, "%s/lib64/libsensors.so", lmsensors_root);   // PAPI Root check.
      dl1 = dlopen(path_name, RTLD_NOW | RTLD_GLOBAL);             // Try to open that path.
   }
 
   // Step 4: Try another explicit install default.
   if (dl1 == NULL && lmsensors_root != NULL) {                          // if root given, try it.
      snprintf(path_name, PATH_MAX, "%s/lib/libsensors.so", lmsensors_root);   // PAPI Root check.
      dl1 = dlopen(path_name, RTLD_NOW | RTLD_GLOBAL);             // Try to open that path.
   }
 
   // Check for failure.
   if (dl1 == NULL) {
      snprintf(_lmsensors_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN, "libsensors.so not found.");
      return(PAPI_ENOSUPP);
   }
 
   // We have dl1. 
 
    sensors_initPtr = dlsym(dl1, "sensors_init");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_init.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_cleanupPtr = dlsym(dl1, "sensors_cleanup");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_cleanup.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_snprintf_chip_namePtr = dlsym(dl1, "sensors_snprintf_chip_name");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_snprintf_chip_name.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_get_labelPtr = dlsym(dl1, "sensors_get_label");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_get_label.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_get_valuePtr = dlsym(dl1, "sensors_get_value");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_get_value.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_get_detected_chipsPtr = dlsym(dl1, "sensors_get_detected_chips");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_get_detected_chips.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_get_featuresPtr = dlsym(dl1, "sensors_get_features");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_get_features.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
    sensors_get_all_subfeaturesPtr = dlsym(dl1, "sensors_get_all_subfeatures");
    if (dlerror() != NULL)
    {
        strncpy(_lmsensors_vector.cmp_info.disabled_reason,
            "lmsensor function sensors_get_all_subfeatures.",PAPI_MAX_STR_LEN);
        return ( PAPI_ENOSUPP );
    }
 
    return ( PAPI_OK );
}

Here is the caller graph for this function:

Variable Documentation

_dl_non_dynamic_init

void(* _dl_non_dynamic_init) (void)

(

void

)

Definition at line 129 of file linux-lmsensors.c.

{
    unsigned id = 0;
    int chip_nr = 0;
    const sensors_chip_name *chip_name;
 
    /* Loop through all the chips, features, subfeatures found */
    while ( ( chip_name =
              sensors_get_detected_chipsPtr( NULL, &chip_nr ) ) != NULL ) {
        int a = 0, b;
        const sensors_feature *feature;
 
        while ( ( feature = sensors_get_featuresPtr( chip_name, &a ) ) ) {
            b = 0;
            while ( ( sensors_get_all_subfeaturesPtr( chip_name, feature,
                                                   &b ) ) ) {
                id++;
            }
        }
    }
 
    return id;
}

_lmsensors_vector

papi_vector_t _lmsensors_vector

Definition at line 701 of file linux-lmsensors.c.

cached_counts

long_long* cached_counts = NULL

static

Definition at line 100 of file linux-lmsensors.c.

dl1

void* dl1 = NULL

static

Definition at line 117 of file linux-lmsensors.c.

lm_sensors_native_table

_lmsensors_native_event_entry_t* lm_sensors_native_table

static

Definition at line 97 of file linux-lmsensors.c.

lmsensors_main

char lmsensors_main[] =PAPI_LMSENSORS_MAIN

static

Definition at line 120 of file linux-lmsensors.c.

num_events

int num_events = 0

static

Definition at line 99 of file linux-lmsensors.c.

sensors_cleanupPtr

void(* sensors_cleanupPtr) (void) ( void  )

static

Definition at line 104 of file linux-lmsensors.c.

sensors_get_all_subfeaturesPtr

const sensors_subfeature *(* sensors_get_all_subfeaturesPtr) (const sensors_chip_name *name, const sensors_feature *feature, int *nr) ( const sensors_chip_name *  name, const sensors_feature *  feature, int *  nr  )

static

Definition at line 113 of file linux-lmsensors.c.

sensors_get_detected_chipsPtr

const sensors_chip_name *(* sensors_get_detected_chipsPtr) (const sensors_chip_name *match, int *nr) ( const sensors_chip_name *  match, int *  nr  )

static

Definition at line 110 of file linux-lmsensors.c.

sensors_get_featuresPtr

const sensors_feature *(* sensors_get_featuresPtr) (const sensors_chip_name *name, int *nr) ( const sensors_chip_name *  name, int *  nr  )

static

Definition at line 112 of file linux-lmsensors.c.

sensors_get_labelPtr

char *(* sensors_get_labelPtr) (const sensors_chip_name *name, const sensors_feature *feature) ( const sensors_chip_name *  name, const sensors_feature *  feature  )

static

Definition at line 107 of file linux-lmsensors.c.

sensors_get_valuePtr

int(* sensors_get_valuePtr) (const sensors_chip_name *name, int subfeat_nr, double *value) ( const sensors_chip_name *  name, int  subfeat_nr, double *  value  )

static

Definition at line 108 of file linux-lmsensors.c.

sensors_initPtr

int(* sensors_initPtr) (FILE *input) ( FILE *  input )

static

Definition at line 103 of file linux-lmsensors.c.

sensors_snprintf_chip_namePtr

int(* sensors_snprintf_chip_namePtr) (char *str, size_t size, const sensors_chip_name *chip) ( char *  str, size_t  size, const sensors_chip_name *  chip  )

static

Definition at line 105 of file linux-lmsensors.c.