linux-lustre.c File Reference

A component for the lustre filesystem. More...

Include dependency graph for linux-lustre.c:

Go to the source code of this file.

Data Structures
struct	STEALTIME_reg_alloc_t
struct	string_list
struct	lustre_fs
struct	LUSTRE_control_state_t
struct	LUSTRE_context_t

Macros
#define	LUSTRE_MAX_COUNTERS   100
#define	LUSTRE_MAX_COUNTER_TERMS   LUSTRE_MAX_COUNTERS

Typedefs
typedef counter_info	LUSTRE_register_t
typedef counter_info	LUSTRE_native_event_entry_t
typedef counter_info	LUSTRE_reg_alloc_t

Functions
static int	resize_native_table ()
static counter_info *	addCounter (const char *name, const char *desc, const char *unit)
static int	addLustreFS (const char *name, const char *procpath_general, const char *procpath_readahead)
static int	init_lustre_counters (void)
static void	read_lustre_counter ()
static void	host_finalize (void)
static int	_lustre_init_component (int cidx)
static int	_lustre_init_thread (hwd_context_t *ctx)
static int	_lustre_shutdown_component (void)
static int	_lustre_shutdown_thread (hwd_context_t *ctx)
static int	_lustre_init_control_state (hwd_control_state_t *ctl)
static int	_lustre_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_lustre_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_lustre_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_lustre_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_lustre_reset (hwd_context_t *ctx, hwd_control_state_t *ctrl)
static int	_lustre_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_lustre_set_domain (hwd_control_state_t *cntrl, int domain)
static int	_lustre_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_lustre_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
static int	_lustre_ntv_enum_events (unsigned int *EventCode, int modifier)

Variables
const char	proc_base_path [] = "/proc/fs/lustre/"
static counter_info **	lustre_native_table = NULL
static int	num_events = 0
static int	table_size = 32
static lustre_fs *	root_lustre_fs = NULL
papi_vector_t	_lustre_vector

Detailed Description

Author

Haihang You (in collaboration with Michael Kluge, TU Dresden) you@e.nosp@m.ecs..nosp@m.utk.e.nosp@m.du

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

Vince Weaver vweav.nosp@m.er1@.nosp@m.eecs..nosp@m.utk..nosp@m.edu

Definition in file linux-lustre.c.

Macro Definition Documentation

LUSTRE_MAX_COUNTER_TERMS

#define LUSTRE_MAX_COUNTER_TERMS   LUSTRE_MAX_COUNTERS

Definition at line 58 of file linux-lustre.c.

LUSTRE_MAX_COUNTERS

#define LUSTRE_MAX_COUNTERS   100

Definition at line 57 of file linux-lustre.c.

Typedef Documentation

LUSTRE_native_event_entry_t

typedef counter_info LUSTRE_native_event_entry_t

Definition at line 61 of file linux-lustre.c.

LUSTRE_reg_alloc_t

typedef counter_info LUSTRE_reg_alloc_t

Definition at line 62 of file linux-lustre.c.

LUSTRE_register_t

typedef counter_info LUSTRE_register_t

Definition at line 60 of file linux-lustre.c.

Function Documentation

_lustre_ctl()

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

static

Definition at line 668 of file linux-lustre.c.

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

_lustre_init_component()

static int _lustre_init_component ( int  cidx )

static

Definition at line 441 of file linux-lustre.c.

{
    SUBDBG("ENTER:\n");
    int ret = PAPI_OK;
 
    resize_native_table();
    ret=init_lustre_counters();
    if (ret!=PAPI_OK) {
       strncpy(_lustre_vector.cmp_info.disabled_reason,
           "No lustre filesystems found",PAPI_MAX_STR_LEN);
      host_finalize();                                         // cleanup.
       SUBDBG("EXIT: ret: %d\n", ret);
       goto fn_fail;
    }
 
    _lustre_vector.cmp_info.num_native_events=num_events;
    _lustre_vector.cmp_info.CmpIdx = cidx;
 
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = ret;
    SUBDBG("EXIT: ret: %d\n", ret);
    return ret;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

_lustre_init_control_state()

static int _lustre_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 512 of file linux-lustre.c.

{
    LUSTRE_control_state_t *lustre_ctl = (LUSTRE_control_state_t *)ctl;
 
    memset(lustre_ctl->start_count,0,sizeof(long long)*LUSTRE_MAX_COUNTERS);
    memset(lustre_ctl->current_count,0,sizeof(long long)*LUSTRE_MAX_COUNTERS);
 
    return PAPI_OK;
}

_lustre_init_thread()

static int _lustre_init_thread ( hwd_context_t *  ctx )

static

Definition at line 475 of file linux-lustre.c.

{
  (void) ctx;
 
  return PAPI_OK;
}

_lustre_ntv_code_to_descr()

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

static

Definition at line 727 of file linux-lustre.c.

{
   SUBDBG("ENTER: EventCode: %#x, name: %p, len: %d\n", EventCode, name, len);
  int event=EventCode;
 
  if (event >=0 && event < num_events) {
   strncpy( name, lustre_native_table[event]->description, len-1 );
    name[len-1] = '\0';
   SUBDBG("EXIT: description: %s\n", name);
    return PAPI_OK;
  }
   SUBDBG("EXIT: PAPI_ENOEVNT\n");
  return PAPI_ENOEVNT;
}

_lustre_ntv_code_to_name()

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

static

Definition at line 707 of file linux-lustre.c.

{
   SUBDBG("ENTER: EventCode: %#x, name: %p, len: %d\n", EventCode, name, len);
  int event=EventCode;
 
  if (event >=0 && event < num_events) {
     strncpy( name, lustre_native_table[event]->name, len-1 );
     name[len-1] = '\0';
   SUBDBG("EXIT: event name: %s\n", name);
     return PAPI_OK;
  }
   SUBDBG("EXIT: PAPI_ENOEVNT\n");
  return PAPI_ENOEVNT;
}

_lustre_ntv_enum_events()

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

static

Definition at line 747 of file linux-lustre.c.

{
   SUBDBG("ENTER: EventCode: %p, modifier: %d\n", EventCode, modifier);
 
    if ( modifier == PAPI_ENUM_FIRST ) {
       if (num_events==0) return PAPI_ENOEVNT;
       *EventCode = 0;
    SUBDBG("EXIT: *EventCode: %#x\n", *EventCode);
       return PAPI_OK;
    }
 
    if ( modifier == PAPI_ENUM_EVENTS ) {
        int index = *EventCode;
 
        if ((index+1 < num_events) && lustre_native_table[index + 1]) {
            *EventCode = *EventCode + 1;
        SUBDBG("EXIT: *EventCode: %#x\n", *EventCode);
            return PAPI_OK;
        } else {
        SUBDBG("EXIT: PAPI_ENOEVNT\n");
            return PAPI_ENOEVNT;
        }
    } 
        
 
   SUBDBG("EXIT: PAPI_EINVAL\n");
    return PAPI_EINVAL;
}

_lustre_read()

static int _lustre_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long **  events, int  flags  )

static

Definition at line 603 of file linux-lustre.c.

{
    (void) ctx;
    ( void ) flags;
 
    LUSTRE_control_state_t *lustre_ctl = (LUSTRE_control_state_t *)ctl;
    int i;
 
    read_lustre_counter(  );
 
    for(i=0;i<lustre_ctl->num_events;i++) {
       lustre_ctl->current_count[i]=
                 lustre_native_table[lustre_ctl->which_counter[i]]->value;
       lustre_ctl->difference[i]=lustre_ctl->current_count[i]-
                                         lustre_ctl->start_count[i];
    }
 
    *events = lustre_ctl->difference;
 
    return PAPI_OK;
 
}

Here is the call graph for this function:

_lustre_reset()

static int _lustre_reset ( hwd_context_t *  ctx, hwd_control_state_t *  ctrl  )

static

Definition at line 634 of file linux-lustre.c.

{
 
  /* re-initializes counter_start values to current */
 
  _lustre_start(ctx,ctrl);
 
  return PAPI_OK;
}

Here is the call graph for this function:

_lustre_set_domain()

static int _lustre_set_domain ( hwd_control_state_t *  cntrl, int  domain  )

static

Definition at line 690 of file linux-lustre.c.

{
    ( void ) cntrl;
    ( void ) domain;
    SUBDBG("ENTER: \n");
 
    // this component does not allow limiting which domains will increment event counts
 
    SUBDBG("EXIT: PAPI_OK\n");
    return PAPI_OK;
}

_lustre_shutdown_component()

static int _lustre_shutdown_component ( void  )

static

Definition at line 487 of file linux-lustre.c.

{
    SUBDBG("ENTER:\n");
    host_finalize(  );
   SUBDBG("EXIT:\n");
    return PAPI_OK;
}

Here is the call graph for this function:

_lustre_shutdown_thread()

static int _lustre_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 499 of file linux-lustre.c.

{
    ( void ) ctx;
 
    return PAPI_OK;
}

_lustre_start()

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

static

Definition at line 553 of file linux-lustre.c.

{
    ( void ) ctx;
 
    LUSTRE_control_state_t *lustre_ctl = (LUSTRE_control_state_t *)ctl;
    int i;
 
    read_lustre_counter(  );
 
    for(i=0;i<lustre_ctl->num_events;i++) {
       lustre_ctl->current_count[i]=
                 lustre_native_table[lustre_ctl->which_counter[i]]->value;
    }
 
    memcpy( lustre_ctl->start_count,
        lustre_ctl->current_count,
        LUSTRE_MAX_COUNTERS * sizeof ( long long ) );
 
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_lustre_stop()

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

static

Definition at line 579 of file linux-lustre.c.

{
 
    (void) ctx;
    LUSTRE_control_state_t *lustre_ctl = (LUSTRE_control_state_t *)ctl;
    int i;
 
    read_lustre_counter(  );
 
    for(i=0;i<lustre_ctl->num_events;i++) {
       lustre_ctl->current_count[i]=
                 lustre_native_table[lustre_ctl->which_counter[i]]->value;
    }
 
    return PAPI_OK;
 
}

Here is the call graph for this function:

_lustre_update_control_state()

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

static

Definition at line 527 of file linux-lustre.c.

{
   SUBDBG("ENTER: ctl: %p, native: %p, count: %d, ctx: %p\n", ctl, native, count, ctx);
    LUSTRE_control_state_t *lustre_ctl = (LUSTRE_control_state_t *)ctl;
    ( void ) ctx;
    int i, index;
 
    for ( i = 0; i < count; i++ ) {
       index = native[i].ni_event;
       lustre_ctl->which_counter[i]=index;
       native[i].ni_position = i;
    }
 
    lustre_ctl->num_events=count;
    SUBDBG("EXIT: PAPI_OK\n");
    return PAPI_OK;
}

addCounter()

static counter_info * addCounter ( const char *  name, const char *  desc, const char *  unit  )

static

add a counter to the list of available counters

Parameters

name	the short name of the counter
desc	a longer description
unit	the unit for this counter

Definition at line 125 of file linux-lustre.c.

{
   SUBDBG("ENTER: name: %s, desc: %s, unit: %s\n", name, desc, unit);
 
    counter_info *cntr;
 
    if ( num_events >= table_size )
    if (PAPI_OK != resize_native_table()) {
        SUBDBG("EXIT: can not resize native table\n" );
            return NULL;
    }
 
    cntr = malloc( sizeof ( counter_info ) );
 
    if ( cntr == NULL ) {
       SUBDBG("EXIT: can not allocate memory for new counter\n" );
       return NULL;
    }
 
    cntr->idx=num_events;
    cntr->name = strdup( name );
    cntr->description = strdup( desc );
    cntr->unit = strdup( unit );
    cntr->value = 0;
 
    lustre_native_table[num_events]=cntr;
 
    num_events++;
 
SUBDBG("EXIT: cntr: %p\n", cntr);
    return cntr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

addLustreFS()

static int addLustreFS ( const char *  name, const char *  procpath_general, const char *  procpath_readahead  )

static

adds a Lustre fs to the fs list and creates the counters for it

Parameters

name	fs name
procpath_general	path to the 'stats' file in /proc/fs/lustre/... for this fs
procpath_readahead	path to the 'readahead' file in /proc/fs/lustre/... for this fs

Definition at line 165 of file linux-lustre.c.

{
    lustre_fs *fs, *last;
    char counter_name[512];
    FILE *fff;
 
    SUBDBG("Adding lustre fs\n");
 
    fs = malloc( sizeof ( lustre_fs ) );
    if ( fs == NULL ) {
       SUBDBG("can not allocate memory for new Lustre FS description\n" );
       return PAPI_ENOMEM;
    }
 
    fs->proc_file=strdup(procpath_general);
    fff = fopen( procpath_general, "r" );
    if ( fff == NULL ) {
      SUBDBG("can not open '%s'\n", procpath_general );
     free(fs->proc_file);                                   // strdup.
      free(fs);                                              // malloc.
      return PAPI_ESYS;
    }
    fclose(fff);
 
    fs->proc_file_readahead = strdup(procpath_readahead);
    fff = fopen( procpath_readahead, "r" );
    if ( fff == NULL ) {
      SUBDBG("can not open '%s'\n", procpath_readahead );
     free(fs->proc_file_readahead);                         // strdup.
     free(fs->proc_file);                                   // strdup.
      free(fs);                                              // malloc.
      return PAPI_ESYS;
    }
    fclose(fff);
 
    sprintf( counter_name, "%s_llread", name );
    if (NULL == (fs->read_cntr = addCounter( counter_name, 
                    "bytes read on this lustre client", 
                    "bytes" ))) {
         free(fs->proc_file_readahead);                         // strdup.
         free(fs->proc_file);                                   // strdup.
          free(fs);                                              // malloc.
            return PAPI_ENOMEM;
    }
 
    sprintf( counter_name, "%s_llwrite", name );
    if ( NULL == (fs->write_cntr = addCounter( counter_name, 
                     "bytes written on this lustre client",
                     "bytes" ))) {
            free(fs->read_cntr);
         free(fs->proc_file_readahead);                         // strdup.
         free(fs->proc_file);                                   // strdup.
          free(fs);                                              // malloc.
            return PAPI_ENOMEM;
    }
 
    sprintf( counter_name, "%s_wrong_readahead", name );
    if ( NULL == (fs->readahead_cntr = addCounter( counter_name, 
                     "bytes read but discarded due to readahead",
                     "bytes" ))) {
            free(fs->read_cntr);
            free(fs->write_cntr);
         free(fs->proc_file_readahead);                         // strdup.
         free(fs->proc_file);                                   // strdup.
          free(fs);                                              // malloc.
            return PAPI_ENOMEM;
    }
 
    fs->next = NULL;
 
    /* Insert into the linked list */
    /* Does this need locking? */
    if ( root_lustre_fs == NULL ) {
        root_lustre_fs = fs;
    } else {
        last = root_lustre_fs;
 
        while ( last->next != NULL )
            last = last->next;
 
        last->next = fs;
    }
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

host_finalize()

static void host_finalize ( void  )

static

frees all allocated resources

Definition at line 394 of file linux-lustre.c.

{
        int i;
    lustre_fs *fs, *next_fs;
    counter_info *cntr;
 
    for(i=0;i<num_events;i++) {
       cntr=lustre_native_table[i];
       if ( cntr != NULL ) {
          free( cntr->name );
          free( cntr->description );
          free( cntr->unit );
          free( cntr );       
       }
       lustre_native_table[i]=NULL;
    }
 
   papi_free(lustre_native_table);     // Free the table itself.
   lustre_native_table = NULL;         // clear the pointer.
    num_events = 0;
   table_size = 32;
 
    fs = root_lustre_fs;
 
    while ( fs != NULL ) {
        next_fs = fs->next;
    free(fs->read_cntr);
    free(fs->write_cntr);
      free(fs->proc_file_readahead);                         // strdup.
      free(fs->proc_file);                                   // strdup.
      free(fs);                                              // malloc.
        fs = next_fs;
    }
 
    root_lustre_fs = NULL;
}

Here is the caller graph for this function:

init_lustre_counters()

static int init_lustre_counters ( void  )

static

goes through proc and tries to discover all mounted Lustre fs

Definition at line 257 of file linux-lustre.c.

{
   SUBDBG("ENTER:\n");
        char lustre_dir[PATH_MAX];
    char path[PATH_MAX];
    char path_readahead[PATH_MAX],path_stats[PATH_MAX];
    char *ptr;
    char fs_name[100];
    int found_luster_fs = 0;
    int idx = 0;
    int tmp_fd;
    DIR *proc_dir;
    struct dirent *entry;
 
    sprintf(lustre_dir,"%s/llite",proc_base_path);
 
    proc_dir = opendir( lustre_dir );
    if ( proc_dir == NULL ) {
      SUBDBG("EXIT: PAPI_ESYS (Cannot open %s)\n",lustre_dir);
       return PAPI_ESYS;
    }
 
   while ( (entry = readdir( proc_dir )) != NULL ) {
       memset( path, 0, PATH_MAX );
       snprintf( path, PATH_MAX - 1, "%s/%s/stats", lustre_dir,
                  entry->d_name );
       SUBDBG("checking for file %s\n", path);
 
       if ( ( tmp_fd = open( path, O_RDONLY ) ) == -1 ) {
           SUBDBG("Path: %s, can not be opened.\n", path);
           continue;
       }
 
      close( tmp_fd );
 
      /* erase \r and \n at the end of path */
      /* why is this necessary?             */
 
      idx = strlen( path );
      idx--;
 
      while ( path[idx] == '\r' || path[idx] == '\n' )
        path[idx--] = 0;
 
      /* Lustre paths are of type server-UUID */
 
      ptr = strstr(path,"llite/") + 6;
     if (ptr == NULL) {
      SUBDBG("Path: %s, missing llite directory, performance event not created.\n", path);
      continue;
      }
 
     strncpy(fs_name, ptr, sizeof(fs_name)-1);
     fs_name[sizeof(fs_name)-1] = '\0';
 
      SUBDBG("found Lustre FS: %s\n", fs_name);
 
      snprintf( path_stats, PATH_MAX - 1,
        "%s/%s/stats",
        lustre_dir,
        entry->d_name );
      SUBDBG("Found file %s\n", path_stats);
 
      snprintf( path_readahead, PATH_MAX - 1,
        "%s/%s/read_ahead_stats",
        lustre_dir,
        entry->d_name );
      SUBDBG("Now checking for file %s\n", path_readahead);
 
      strcpy( ptr, "read_ahead_stats" );
      addLustreFS( fs_name, path_stats, path_readahead );
      found_luster_fs++;
    }
    closedir( proc_dir );
 
    if (found_luster_fs == 0) {
        SUBDBG("EXIT: PAPI_ESYS (No luster file systems found)\n");
        return PAPI_ESYS;
    }
 
   SUBDBG("EXIT: PAPI_OK\n");
    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_lustre_counter()

static void read_lustre_counter ( )

static

updates all Lustre related counters

Definition at line 345 of file linux-lustre.c.

{
    lustre_fs *fs = root_lustre_fs;
    FILE *fff;
    char buffer[BUFSIZ];
 
    while ( fs != NULL ) {
 
      /* read values from stats file */
      fff=fopen(fs->proc_file,"r" );
      if (fff != NULL) {
          while(1) {
            if (fgets(buffer,BUFSIZ,fff)==NULL) break;
    
            if (strstr( buffer, "write_bytes" )) {
              sscanf(buffer,"%*s %*d %*s %*s %*d %*d %llu",&fs->write_cntr->value);
              SUBDBG("Read %llu write_bytes\n",fs->write_cntr->value);
            }
    
            if (strstr( buffer, "read_bytes" )) {
              sscanf(buffer,"%*s %*d %*s %*s %*d %*d %llu",&fs->read_cntr->value);
              SUBDBG("Read %llu read_bytes\n",fs->read_cntr->value);
            }
          }
          fclose(fff);
      }
 
      fff=fopen(fs->proc_file_readahead,"r");
      if (fff != NULL) {
          while(1) {
            if (fgets(buffer,BUFSIZ,fff)==NULL) break;
    
            if (strstr( buffer, "read but discarded")) {
               sscanf(buffer,"%*s %*s %*s %llu",&fs->readahead_cntr->value);
               SUBDBG("Read %llu discared\n",fs->readahead_cntr->value);
               break;
            }
          }
          fclose(fff);
      }
      fs = fs->next;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

resize_native_table()

static int resize_native_table ( )

static

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

                                 {
    SUBDBG("ENTER:\n");
    counter_info** new_table;
    int new_size = table_size*2;
    new_table = (counter_info**)papi_calloc(new_size, sizeof(counter_info*));
    if (NULL==new_table) {
        SUBDBG("EXIT: PAPI_ENOMEM\n");
        return PAPI_ENOMEM;
    }
    if ( lustre_native_table) {
        memcpy(new_table, lustre_native_table, sizeof(counter_info*) * table_size );
        papi_free(lustre_native_table);
    }
    lustre_native_table = new_table;
    table_size*=2;
    SUBDBG("EXIT: PAPI_OK\n");
    return PAPI_OK;
}

Here is the caller graph for this function:

Variable Documentation

_lustre_vector

papi_vector_t _lustre_vector

Definition at line 94 of file linux-lustre.c.

lustre_native_table

counter_info** lustre_native_table = NULL

static

Definition at line 87 of file linux-lustre.c.

num_events

int num_events = 0

static

Definition at line 88 of file linux-lustre.c.

proc_base_path

const char proc_base_path[] = "/proc/fs/lustre/"

Definition at line 84 of file linux-lustre.c.

root_lustre_fs

lustre_fs* root_lustre_fs = NULL

static

Definition at line 92 of file linux-lustre.c.

table_size

int table_size = 32

static

Definition at line 89 of file linux-lustre.c.