Menu
▾
▴
[Sblim-commit] gather/plugin metricStorage.c, NONE, 1.1 repositoryStorage.c, NONE, 1.1
|
From: Tyrel D. <ty...@us...> - 2011-11-17 01:01:28
|
Update of /cvsroot/sblim/gather/plugin
In directory vz-cvs-3.sog:/tmp/cvs-serv8026/plugin
Added Files:
metricStorage.c repositoryStorage.c
Log Message:
Fixed 3439075: add Host Block IO metrics
--- NEW FILE: repositoryStorage.c ---
/*
* $Id: repositoryStorage.c,v 1.1 2011/11/17 01:01:26 tyreld Exp $
*
* (C) Copyright IBM Corp. 2011
*
* THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
* ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
* CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
*
* You can obtain a current copy of the Eclipse Public License from
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* Author: Tyrel Datwyler <ty...@us...>
* Contributors:
*
* Description:
* Repository Plugin of the following IP Protocol Endpoint specific metrics :
*
* _BlockStorage
*
*/
/* ---------------------------------------------------------------------------*/
#include <mplugin.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ---------------------------------------------------------------------------*/
static MetricCalculationDefinition metricCalcDef[4];
static MetricCalculator metricCalcBlockStorage;
static MetricCalculator metricCalcRead;
static MetricCalculator metricCalcWrite;
static MetricCalculator metricCalcCapacity;
/* unit definitions */
static char * muBytes = "Bytes";
static char * muKbytes = "Kilobytes";
static char * muNa ="N/A";
/* ---------------------------------------------------------------------------*/
enum indices { READ, WRITE, CAPACITY };
static unsigned long long dev_getData(char * data, char index);
/* ---------------------------------------------------------------------------*/
int _DefinedRepositoryMetrics( MetricRegisterId *mr,
const char *pluginname,
size_t *mcnum,
MetricCalculationDefinition **mc ) {
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Retrieving metric calculation definitions\n",
__FILE__,__LINE__);
#endif
if (mr==NULL||mcnum==NULL||mc==NULL) {
fprintf(stderr,"--- %s(%i) : invalid parameter list\n",__FILE__,__LINE__);
return -1;
}
metricCalcDef[0].mcVersion=MD_VERSION;
metricCalcDef[0].mcName="_BlockStorage";
metricCalcDef[0].mcId=mr(pluginname,metricCalcDef[0].mcName);
metricCalcDef[0].mcMetricType=MD_PERIODIC|MD_RETRIEVED|MD_POINT;
metricCalcDef[0].mcIsContinuous=MD_FALSE;
metricCalcDef[0].mcCalculable=MD_NONCALCULABLE;
metricCalcDef[0].mcDataType=MD_STRING;
metricCalcDef[0].mcCalc=metricCalcBlockStorage;
metricCalcDef[0].mcUnits=muNa;
metricCalcDef[1].mcVersion=MD_VERSION;
metricCalcDef[1].mcName="Read";
metricCalcDef[1].mcId=mr(pluginname,metricCalcDef[1].mcName);
metricCalcDef[1].mcMetricType=MD_PERIODIC|MD_CALCULATED|MD_INTERVAL;
metricCalcDef[1].mcChangeType=MD_GAUGE;
metricCalcDef[1].mcIsContinuous=MD_TRUE;
metricCalcDef[1].mcCalculable=MD_SUMMABLE;
metricCalcDef[1].mcDataType=MD_UINT64;
metricCalcDef[1].mcAliasId=metricCalcDef[0].mcId;
metricCalcDef[1].mcCalc=metricCalcRead;
metricCalcDef[1].mcUnits=muKbytes;
metricCalcDef[2].mcVersion=MD_VERSION;
metricCalcDef[2].mcName="Write";
metricCalcDef[2].mcId=mr(pluginname,metricCalcDef[2].mcName);
metricCalcDef[2].mcMetricType=MD_PERIODIC|MD_CALCULATED|MD_INTERVAL;
metricCalcDef[2].mcChangeType=MD_GAUGE;
metricCalcDef[2].mcIsContinuous=MD_TRUE;
metricCalcDef[2].mcCalculable=MD_SUMMABLE;
metricCalcDef[2].mcDataType=MD_UINT64;
metricCalcDef[2].mcAliasId=metricCalcDef[0].mcId;
metricCalcDef[2].mcCalc=metricCalcWrite;
metricCalcDef[2].mcUnits=muKbytes;
metricCalcDef[3].mcVersion=MD_VERSION;
metricCalcDef[3].mcName="Capacity";
metricCalcDef[3].mcId=mr(pluginname,metricCalcDef[3].mcName);
metricCalcDef[3].mcMetricType=MD_PERIODIC|MD_CALCULATED|MD_POINT;
metricCalcDef[3].mcChangeType=MD_GAUGE;
metricCalcDef[3].mcIsContinuous=MD_TRUE;
metricCalcDef[3].mcCalculable=MD_NONSUMMABLE;
metricCalcDef[3].mcDataType=MD_UINT64;
metricCalcDef[3].mcAliasId=metricCalcDef[0].mcId;
metricCalcDef[3].mcCalc=metricCalcCapacity;
metricCalcDef[3].mcUnits=muBytes;
*mcnum=4;
*mc=metricCalcDef;
return 0;
}
/* ---------------------------------------------------------------------------*/
/* BlockStorage */
/* ---------------------------------------------------------------------------*/
/*
* The raw data BlockStorage has the following syntax :
*
* <read kb>:<write kb>:<capacity (in bytes)>:
*
*/
size_t metricCalcBlockStorage( MetricValue *mv,
int mnum,
void *v,
size_t vlen ) {
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Calculate BlockStorage\n",
__FILE__,__LINE__);
#endif
/* plain copy */
if (mv && (vlen>=mv->mvDataLength) && (mnum==1) ) {
memcpy(v,mv->mvData,mv->mvDataLength);
return mv->mvDataLength;
}
return -1;
}
/* ---------------------------------------------------------------------------*/
/* Read */
/* ---------------------------------------------------------------------------*/
size_t metricCalcRead( MetricValue *mv,
int mnum,
void *v,
size_t vlen ) {
unsigned long long rt = 0;
unsigned long long r1 = 0;
unsigned long long r2 = 0;
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Calculate Read\n",
__FILE__,__LINE__);
#endif
if ( mv && (vlen>=sizeof(unsigned long long)) && (mnum>=1) ) {
r1 = dev_getData(mv[0].mvData, READ);
if( mnum > 1 ) {
r2 = dev_getData(mv[mnum-1].mvData, READ);
rt = r1-r2;
}
else { rt = r1; }
memcpy(v,&rt,sizeof(unsigned long long));
return sizeof(unsigned long long);
}
return -1;
}
/* ---------------------------------------------------------------------------*/
/* Write */
/* ---------------------------------------------------------------------------*/
size_t metricCalcWrite( MetricValue *mv,
int mnum,
void *v,
size_t vlen ) {
unsigned long long wt = 0;
unsigned long long w1 = 0;
unsigned long long w2 = 0;
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Calculate Write\n",
__FILE__,__LINE__);
#endif
if ( mv && (vlen>=sizeof(unsigned long long)) && (mnum>=1) ) {
w1 = dev_getData(mv[0].mvData, WRITE);
if( mnum > 1 ) {
w2 = dev_getData(mv[mnum-1].mvData, WRITE);
wt = w1-w2;
}
else { wt = w1; }
memcpy(v,&wt,sizeof(unsigned long long));
return sizeof(unsigned long long);
}
return -1;
}
/* ---------------------------------------------------------------------------*/
/* Capacity */
/* ---------------------------------------------------------------------------*/
size_t metricCalcCapacity( MetricValue *mv,
int mnum,
void *v,
size_t vlen ) {
unsigned long long ct = 0;
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Calculate Capacity\n",
__FILE__,__LINE__);
#endif
if ( mv && (vlen>=sizeof(unsigned long long)) && (mnum>=1) ) {
ct = dev_getData(mv[0].mvData, CAPACITY);
memcpy(v,&ct,sizeof(unsigned long long));
return sizeof(unsigned long long);
}
return -1;
}
/* ---------------------------------------------------------------------------*/
/* tool functions on BlockStorage */
/* ---------------------------------------------------------------------------*/
unsigned long long dev_getData(char * data, char index) {
char * hlp = NULL;
char * end = NULL;
char bytes[128];
unsigned long long val = 0;
int i = 0;
hlp = data;
if ((end = strchr(hlp, ':')) != NULL) {
for (i = 0; i < index; i++) {
hlp = ++end;
if ((end = strchr(hlp, ':')) == NULL) {
return val;
}
}
memset(bytes, 0, sizeof(bytes));
strncpy(bytes, hlp, strlen(hlp) - strlen(end));
val = strtoll(bytes, (char**) NULL, 10);
}
return val;
}
/* ---------------------------------------------------------------------------*/
/* end of repositoryStorage.c */
/* ---------------------------------------------------------------------------*/
--- NEW FILE: metricStorage.c ---
/*
* $Id: metricStorage.c,v 1.1 2011/11/17 01:01:26 tyreld Exp $
*
* (C) Copyright IBM Corp. 2011
*
* THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
* ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
* CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
*
* You can obtain a current copy of the Eclipse Public License from
* http://www.opensource.org/licenses/eclipse-1.0.php
*
* Author: Tyrel Datwyler <ty...@us...>
* Contributors:
*
* Description:
* Metrics Gatherer Plugin of the following Storage specific
* metrics :
*
* _BlockStorage
*
*/
/* ---------------------------------------------------------------------------*/
#include <mplugin.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <limits.h>
#include <math.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <fcntl.h>
#ifndef ULLONG_MAX
# define ULLONG_MAX 18446744073709551615ULL
#endif
#define ULL_CHAR_MAX ((int) ((log(ULLONG_MAX)) / (log(10)) + 1))
/* ---------------------------------------------------------------------------*/
static MetricDefinition metricDef[1];
static MetricRetriever metricRetrBlockStorage;
#define DISKSTATS "/proc/diskstats"
/* ---------------------------------------------------------------------------*/
int _DefinedMetrics( MetricRegisterId *mr,
const char * pluginname,
size_t *mdnum,
MetricDefinition **md ) {
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Retrieving metric definitions\n",
__FILE__,__LINE__);
#endif
if (mr==NULL||mdnum==NULL||md==NULL) {
fprintf(stderr,"--- %s(%i) : invalid parameter list\n",__FILE__,__LINE__);
return -1;
}
metricDef[0].mdVersion=MD_VERSION;
metricDef[0].mdName="_BlockStorage";
metricDef[0].mdReposPluginName="librepositoryStorage.so";
metricDef[0].mdId=mr(pluginname,metricDef[0].mdName);
metricDef[0].mdSampleInterval=60;
metricDef[0].mproc=metricRetrBlockStorage;
metricDef[0].mdeal=free;
*mdnum=1;
*md=metricDef;
return 0;
}
int _StartStopMetrics (int starting) {
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : %s metric processing\n",
__FILE__,__LINE__,starting?"Starting":"Stopping");
#endif
return 0;
}
/* ---------------------------------------------------------------------------*/
/* BlockStorage */
/* ---------------------------------------------------------------------------*/
/*
* The raw data BlockStorage has the following syntax :
*
* <read kb>:<write kb>:<capacity (in bytes)>:
*
*/
int metricRetrBlockStorage( int mid, MetricReturner mret ) {
MetricValue * mv = NULL;
FILE * fhd = NULL;
char * ptr = NULL;
char * end = NULL;
char blk[200];
char dev[210];
char buf[60000];
char values[(3*ULL_CHAR_MAX)+4];
size_t bytes_read = 0;
int i = 0;
int fd = 0;
unsigned long long read, write, capacity = 0;
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Retrieving BlockStorage\n",
__FILE__,__LINE__);
#endif
if (mret==NULL) { fprintf(stderr,"Returner pointer is NULL\n"); }
else {
#ifdef DEBUG
fprintf(stderr,"--- %s(%i) : Sampling for metric BlockStorage ID %d\n",
__FILE__,__LINE__,mid);
#endif
if( (fhd = fopen(DISKSTATS,"r")) != NULL ) {
bytes_read = fread(buf, 1, sizeof(buf)-1, fhd);
buf[bytes_read] = 0; /* safeguard end of buffer */
if( bytes_read > 0 ) {
ptr = buf;
while( (end = strchr(ptr,'\n')) != NULL ) {
sscanf(ptr,
" %*s %*s %[a-z0-9] %*s %*s %lld %*s %*s %*s %lld",
blk, &read, &write);
sprintf(dev, "/dev/%s", blk);
fd = open(dev, O_RDONLY | O_NONBLOCK);
if (fd > -1) {
ioctl(fd, BLKGETSIZE64, &capacity);
}
read = read / 2; /* convert form sectors to kb */
write = write / 2; /* 512 bytes/sector, 1kb/1024 bytes = 1kb/2 sectors */
memset(values,0,sizeof(values));
sprintf(values,"%lld:%lld:%lld:",
read, write, capacity);
mv = calloc(1, sizeof(MetricValue) +
(strlen(values)+1) +
(strlen(dev)+1) );
if (mv) {
mv->mvId = mid;
mv->mvTimeStamp = time(NULL);
mv->mvDataType = MD_STRING;
mv->mvDataLength = (strlen(values)+1);
mv->mvData = (char*)mv + sizeof(MetricValue);
strcpy(mv->mvData,values);
mv->mvResource = (char*)mv + sizeof(MetricValue) + (strlen(values)+1);
strcpy(mv->mvResource,dev);
mret(mv);
}
ptr = end+1;
i++;
}
fclose(fhd);
}
else { return -1; }
}
return i;
}
return -1;
}
/* ---------------------------------------------------------------------------*/
/* end of metricStorage.c */
/* ---------------------------------------------------------------------------*/
|
