void initMemory( struct SensorModul* sm ) {
long i = sysconf( _SC_PAGESIZE );
pageshift = 0;
while( (i >>= 1) > 0 )
pageshift++;
/* calculate an amount to shift to K values */
/* remember that log base 2 of 1024 is 10 (i.e.: 2^10 = 1024) */
pageshift -= 10;
/* now determine which pageshift function is appropriate for the
result (have to because x << y is undefined for y < 0) */
if( pageshift > 0 ) {
/* this is the most likely */
p_pagetok = pagetok_left;
} else if( pageshift == 0 ) {
p_pagetok = pagetok_none;
} else {
p_pagetok = pagetok_right;
pageshift = -pageshift;
}
#ifdef HAVE_KSTAT
registerMonitor( "mem/physical/free", "integer",
printMemFree, printMemFreeInfo, sm );
registerMonitor( "mem/physical/used", "integer",
printMemUsed, printMemUsedInfo, sm );
#endif
registerMonitor( "mem/swap/free", "integer",
printSwapFree, printSwapFreeInfo, sm );
registerMonitor( "mem/swap/used", "integer",
printSwapUsed, printSwapUsedInfo, sm );
}
void initLoadAvg(struct SensorModul *sm)
{
#ifdef HAVE_KSTAT
registerMonitor("cpu/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm);
registerMonitor("cpu/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm);
registerMonitor("cpu/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm);
#endif
}
void initLoadAvg(struct SensorModul* sm ) {
registerMonitor( "cpu/loadavg1", "float",
printLoadAvg1, printLoadAvg1Info, sm );
registerMonitor( "cpu/loadavg5", "float",
printLoadAvg5, printLoadAvg5Info, sm );
registerMonitor( "cpu/loadavg15", "float",
printLoadAvg15, printLoadAvg15Info, sm );
}
void initCpuInfo(struct SensorModul *sm)
{
/* Total CPU load */
registerMonitor("cpu/user", "integer", printCPUUser, printCPUUserInfo, sm);
registerMonitor("cpu/nice", "integer", printCPUNice, printCPUNiceInfo, sm);
registerMonitor("cpu/sys", "integer", printCPUSys, printCPUSysInfo, sm);
registerMonitor("cpu/idle", "integer", printCPUIdle, printCPUIdleInfo, sm);
registerMonitor("cpu/interrupt", "integer", printCPUInterrupt, printCPUInterruptInfo, sm);
updateCpuInfo();
}
void initLoadAvg( struct SensorModul* sm )
{
if ( updateLoadAvg() < 0 ) {
LoadAvgOK = -1;
return;
} else
LoadAvgOK = 1;
registerMonitor( "cpu/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm );
registerMonitor( "cpu/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm );
registerMonitor( "cpu/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm );
}
void initCpuInfo(struct SensorModul *sm)
{
/* Total CPU load */
registerMonitor("cpu/user", "integer", printCPUUser, printCPUUserInfo, sm);
registerMonitor("cpu/nice", "integer", printCPUNice, printCPUNiceInfo, sm);
registerMonitor("cpu/sys", "integer", printCPUSys, printCPUSysInfo, sm);
registerMonitor("cpu/idle", "integer", printCPUIdle, printCPUIdleInfo, sm);
kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open");
kvm_nlist(kd, my_nlist);
cp_time_offset = my_nlist[0].n_value;
updateCpuInfo();
}
void
initApm(struct SensorModul* sm)
{
if ((ApmFD = open(APMDEV, O_RDONLY)) < 0)
return;
if (updateApm() < 0)
return;
registerMonitor("apm/batterycharge", "integer", printApmBatFill,
printApmBatFillInfo, sm);
registerMonitor("apm/remainingtime", "integer", printApmBatTime,
printApmBatTimeInfo, sm);
}
void initLoadAvg(struct SensorModul* sm)
{
if (updateLoadAvg() < 0)
return;
registerMonitor("cpu/system/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm);
registerMonitor("cpu/system/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm);
registerMonitor("cpu/system/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm);
/* Monitor names changed from kde3 => kde4. Remain compatible with legacy requests when possible. */
registerLegacyMonitor("cpu/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm);
registerLegacyMonitor("cpu/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm);
registerLegacyMonitor("cpu/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm);
}
void initLogFile(struct SensorModul* sm)
{
char monitor[1024];
ConfigLogFile *entry;
registerCommand("logfile_register", registerLogFile);
registerCommand("logfile_unregister", unregisterLogFile);
registerCommand("logfile_registered", printRegistered);
for (entry = first_ctnr(LogFileList); entry; entry = next_ctnr(LogFileList))
{
FILE* fp;
/* register the log file if we can actually read the file. */
if ((fp = fopen(entry->path, "r")) != NULL)
{
fclose(fp);
snprintf(monitor, 1024, "logfiles/%s", entry->name);
registerMonitor(monitor, "logfile", printLogFile,
printLogFileInfo, sm);
}
}
LogFiles = new_ctnr();
}
void initAcpiFan(struct SensorModul *sm)
{
char th_ref[ ACPIFILENAMELENGTHMAX ];
DIR *d = NULL;
struct dirent *de;
d = opendir(FAN_DIR);
if (d == NULL) {
/* print_error( "Directory \'" THERMAL_ZONE_DIR
"\' does not exist or is not readable.\n"
"Load the ACPI thermal kernel module or compile it into your kernel.\n" );
*/
AcpiFans = -1;
return;
}
AcpiFans = 0;
while ( (de = readdir(d)) != NULL ) {
if ( ( strcmp( de->d_name, "." ) == 0 )
|| ( strcmp( de->d_name, ".." ) == 0 ) ) {
continue;
}
AcpiFans++;
snprintf(th_ref, sizeof(th_ref),
"acpi/fan/%s/state", de->d_name);
registerMonitor(th_ref, "integer", printFanState,
printFanStateInfo, sm);
}
return;
}
void initLoadAvg( struct SensorModul* sm )
{
if ( updateLoadAvg() < 0 ) {
LoadAvgOK = -1;
return;
} else
LoadAvgOK = 1;
registerMonitor( "cpu/system/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm );
registerMonitor( "cpu/system/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm );
registerMonitor( "cpu/system/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm );
/* Register some legacy monitors. These will be hidden from the module list. */
registerLegacyMonitor( "cpu/loadavg1", "float", printLoadAvg1, printLoadAvg1Info, sm );
registerLegacyMonitor( "cpu/loadavg5", "float", printLoadAvg5, printLoadAvg5Info, sm );
registerLegacyMonitor( "cpu/loadavg15", "float", printLoadAvg15, printLoadAvg15Info, sm );
}
static void processCpuInfo(void)
{
char format[32];
char tag[32];
char value[256];
char *cibp = CpuInfoBuf;
int cpuId = 0;
if(!CpuInfoOK)
return;
sprintf(format, "%%%d[^:]: %%%d[^\n]\n", (int)sizeof(tag) - 1, (int)sizeof(value) - 1);
while(sscanf(cibp, format, tag, value) == 2)
{
char *p;
tag[sizeof(tag) - 1] = '\0';
value[sizeof(value) - 1] = '\0';
/* remove trailing whitespaces */
p = tag + strlen(tag) - 1;
/* remove trailing whitespaces */
while((*p == ' ' || *p == '\t') && p > tag)
*p-- = '\0';
if(strcmp(tag, "processor") == 0)
{
if(sscanf(value, "%d", &cpuId) == 1)
{
if(cpuId >= CPUs)
{
char cmdName[24];
if(Clocks)
free(Clocks);
CPUs = cpuId + 1;
Clocks = malloc(CPUs * sizeof(float));
snprintf(cmdName, sizeof(cmdName) - 1, "cpu%d/clock", cpuId);
registerMonitor(cmdName, "float", printCPUxClock, printCPUxClockInfo, CpuInfoSM);
}
}
}
else if(strcmp(tag, "cpu MHz") == 0)
sscanf(value, "%f", &Clocks[cpuId]);
/* Move cibp to begining of next line, if there is one. */
cibp = strchr(cibp, '\n');
if(cibp)
cibp++;
else
cibp = CpuInfoBuf + strlen(CpuInfoBuf);
}
Dirty = 0;
}
void initNetDev(struct SensorModul* sm)
{
int i;
char monitor[1024];
gettimeofday(&old_tv, (struct timezone *)0);
NetDevSM = sm;
updateNetDev();
for (i = 0; i < NetDevCnt; i++) {
/* init data */
NetDevsOld[i] = NetDevs[i];
/* register monitors */
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/receiver/data", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevRecBytes, printNetDevRecBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/receiver/packets", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevRecBytes, printNetDevRecBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/receiver/errors", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevRecBytes, printNetDevRecBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/receiver/drops", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevRecBytes, printNetDevRecBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/receiver/multicast", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevRecBytes, printNetDevRecBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/transmitter/data", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevSentBytes, printNetDevSentBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/transmitter/packets", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevSentBytes, printNetDevSentBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/transmitter/errors", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevSentBytes, printNetDevSentBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/transmitter/multicast", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevSentBytes, printNetDevSentBytesInfo, NetDevSM);
snprintf(monitor, sizeof(monitor), "network/interfaces/%s/transmitter/collisions", NetDevs[i].name);
registerMonitor(monitor, "integer", printNetDevSentBytes, printNetDevSentBytesInfo, NetDevSM);
}
}
void initAcpiBattery( struct SensorModul* sm )
{
DIR *d;
struct dirent *de;
char s[ ACPIFILENAMELENGTHMAX ];
if ( ( d = opendir( "/proc/acpi/battery" ) ) == NULL ) {
AcpiBatteryNum = -1;
return;
} else {
AcpiBatteryNum = 0;
while ( ( de = readdir( d ) ) )
if ( ( strcmp( de->d_name, "." ) != 0 ) && ( strcmp( de->d_name, ".." ) != 0 ) ) {
strncpy( AcpiBatteryNames[ AcpiBatteryNum ], de->d_name, 8 );
snprintf( s, sizeof( s ), "acpi/battery/%d/batterycharge", AcpiBatteryNum );
registerMonitor( s, "integer", printAcpiBatFill, printAcpiBatFillInfo, sm );
snprintf( s, sizeof( s ), "acpi/battery/%d/batteryusage", AcpiBatteryNum );
registerMonitor( s, "integer", printAcpiBatUsage, printAcpiBatUsageInfo, sm);
AcpiBatteryCharge[ AcpiBatteryNum ] = 0;
AcpiBatteryNum++;
}
}
}
void initProcessList( struct SensorModul* sm ) {
if( (procdir = opendir( PROCDIR )) == NULL ) {
print_error( "cannot open \"%s\" for reading\n", PROCDIR );
return;
}
pagesz=getpagesize();
ProcessList = new_ctnr();
updateProcessList();
/*
* register the supported monitors & commands
*/
registerMonitor( "pscount", "integer",
printProcessCount, printProcessCountInfo, sm );
registerMonitor( "ps", "table",
printProcessList, printProcessListInfo, sm );
if (!RunAsDaemon)
{
registerCommand("kill", killProcess);
registerCommand("setpriority", setPriority);
}
}
void initMemory(struct SensorModul *sm)
{
/**
Make sure that /proc/meminfo exists and is readable. If not we do
not register any monitors for memory.
*/
if(updateMemory() < 0)
return;
registerMonitor("mem/physical/free", "integer", printMFree, printMFreeInfo, sm);
registerMonitor("mem/physical/used", "integer", printUsed, printUsedInfo, sm);
registerMonitor("mem/physical/application", "integer", printAppl, printApplInfo, sm);
registerMonitor("mem/physical/buf", "integer", printBuffers, printBuffersInfo, sm);
registerMonitor("mem/physical/cached", "integer", printCached, printCachedInfo, sm);
registerMonitor("mem/swap/used", "integer", printSwapUsed, printSwapUsedInfo, sm);
registerMonitor("mem/swap/free", "integer", printSwapFree, printSwapFreeInfo, sm);
}
static int initStatDisk( char* tag, char* buf, const char* label,
const char* shortLabel, int idx, cmdExecutor ex, cmdExecutor iq )
{
char sensorName[ 128 ];
gettimeofday( &lastSampling, 0 );
if ( strcmp( label, tag ) == 0 ) {
unsigned int i;
buf = buf + strlen( label ) + 1;
for ( i = 0; i < DiskCount; ++i ) {
sscanf( buf, "%lu", &DiskLoad[ i ].s[ idx ].old );
while ( *buf && isblank( *buf++ ) );
while ( *buf && isdigit( *buf++ ) );
sprintf( sensorName, "disk/disk%d/%s", i, shortLabel );
registerMonitor( sensorName, "float", ex, iq, StatSM );
}
return 1;
}
return 0;
}
void initMemory(struct SensorModul *sm)
{
char *nlistf = NULL;
char *memf = NULL;
char buf[_POSIX2_LINE_MAX];
if((kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf)) == NULL)
{
log_error("kvm_openfiles()");
return;
}
registerMonitor("mem/physical/free", "integer", printMFree, printMFreeInfo, sm);
registerMonitor("mem/physical/used", "integer", printUsed, printUsedInfo, sm);
registerMonitor("mem/physical/buf", "integer", printBuffers, printBuffersInfo, sm);
registerMonitor("mem/physical/cached", "integer", printCached, printCachedInfo, sm);
registerMonitor("mem/swap/free", "integer", printSwapFree, printSwapFreeInfo, sm);
registerMonitor("mem/swap/used", "integer", printSwapUsed, printSwapUsedInfo, sm);
}
static int process24DiskIO( const char* buf ) {
/* Process disk_io lines as provided by 2.4.x kernels.
* disk_io: (2,0):(3,3,6,0,0) (3,0):(1413012,511622,12155382,901390,26486215) */
int major, minor;
unsigned long total, rblk, rio, wblk, wio;
DiskIOInfo* ptr = DiskIO;
DiskIOInfo* last = 0;
char sensorName[ 128 ];
const char* p;
p = buf + strlen( "disk_io: " );
while ( p && *p ) {
if ( sscanf( p, "(%d,%d):(%lu,%lu,%lu,%lu,%lu)", &major, &minor,
&total, &rio, &rblk, &wio, &wblk ) != 7 )
return -1;
last = 0;
ptr = DiskIO;
while ( ptr ) {
if ( ptr->major == major && ptr->minor == minor ) {
/* The IO device has already been registered. */
ptr->total.delta = total - ptr->total.old;
ptr->total.old = total;
ptr->rio.delta = rio - ptr->rio.old;
ptr->rio.old = rio;
ptr->wio.delta = wio - ptr->wio.old;
ptr->wio.old = wio;
ptr->rblk.delta = rblk - ptr->rblk.old;
ptr->rblk.old = rblk;
ptr->wblk.delta = wblk - ptr->wblk.old;
ptr->wblk.old = wblk;
ptr->alive = 1;
break;
}
last = ptr;
ptr = ptr->next;
}
if ( !ptr ) {
/* The IO device has not been registered yet. We need to add it. */
ptr = (DiskIOInfo*)malloc( sizeof( DiskIOInfo ) );
ptr->major = major;
ptr->minor = minor;
/* 2.6 gives us a nice device name. On 2.4 we get nothing */
ptr->devname = (char *)malloc( DISKDEVNAMELEN );
memset( ptr->devname, 0, DISKDEVNAMELEN );
ptr->total.delta = 0;
ptr->total.old = total;
ptr->rio.delta = 0;
ptr->rio.old = rio;
ptr->wio.delta = 0;
ptr->wio.old = wio;
ptr->rblk.delta = 0;
ptr->rblk.old = rblk;
ptr->wblk.delta = 0;
ptr->wblk.old = wblk;
ptr->alive = 1;
ptr->next = 0;
if ( last ) {
/* Append new entry at end of list. */
last->next = ptr;
}
else {
/* List is empty, so we insert the fist element into the list. */
DiskIO = ptr;
}
sprintf( sensorName, "disk/%s_(%d:%d)24/total", ptr->devname, major, minor );
registerMonitor( sensorName, "float", print24DiskIO, print24DiskIOInfo, StatSM );
sprintf( sensorName, "disk/%s_(%d:%d)24/rio", ptr->devname, major, minor );
registerMonitor( sensorName, "float", print24DiskIO, print24DiskIOInfo, StatSM );
sprintf( sensorName, "disk/%s_(%d:%d)24/wio", ptr->devname, major, minor );
registerMonitor( sensorName, "float", print24DiskIO, print24DiskIOInfo, StatSM );
sprintf( sensorName, "disk/%s_(%d:%d)24/rblk", ptr->devname, major, minor );
registerMonitor( sensorName, "float", print24DiskIO, print24DiskIOInfo, StatSM );
sprintf( sensorName, "disk/%s_(%d:%d)24/wblk", ptr->devname, major, minor );
registerMonitor( sensorName, "float", print24DiskIO, print24DiskIOInfo, StatSM );
}
/* Move p after the second ')'. We can safely assume that
* those two ')' exist. */
p = strchr( p, ')' ) + 1;
p = strchr( p, ')' ) + 1;
if ( p && *p )
p = strchr( p, '(' );
}
return 0;
}
void
initCpuInfo(struct SensorModul* sm)
{
size_t len;
int id;
char name[SYSCTL_ID_LEN];
int minfreq, maxfreq;
len = sizeof(cpus);
/* XXX: this is a guess */
sysctlbyname("kern.smp.active", &cpus, &len, NULL, 0);
/* NOTE: cpus may be 0, which implies 1 */
cpus = cpus ? cpus : 1;
len = sizeof(cores);
sysctlbyname("kern.smp.cpus", &cores, &len, NULL, 0);
len = sizeof(maxcpus);
sysctlbyname("kern.smp.maxcpus", &maxcpus, &len, NULL, 0);
/* Core/process count */
registerMonitor("system/processors", "integer", printNumCpus, printNumCpusInfo, sm);
registerMonitor("system/cores", "integer", printNumCores, printNumCoresInfo, sm);
/*
* CPU Loads
*/
if ((cp_time = malloc(sizeof(long) * CPUSTATES * (cores * 4 + 1))) == NULL) {
log_error("out of memory for cp_time");
return;
}
cp_old = &cp_time[cores];
cp_diff = &cp_old[cores];
cpu_states = &cp_diff[cores];
/* Total CPU load */
registerMonitor("cpu/system/user", "float", printCPUUser, printCPUUserInfo, sm);
registerMonitor("cpu/system/nice", "float", printCPUNice, printCPUNiceInfo, sm);
registerMonitor("cpu/system/sys", "float", printCPUSys, printCPUSysInfo, sm);
registerMonitor("cpu/system/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, sm);
registerMonitor("cpu/system/intr", "float", printCPUIntr, printCPUIntrInfo, sm);
registerMonitor("cpu/system/idle", "float", printCPUIdle, printCPUIdleInfo, sm);
/* Monitor names changed from kde3 => kde4. Remain compatible with legacy requests when possible. */
registerLegacyMonitor("cpu/user", "float", printCPUUser, printCPUUserInfo, sm);
registerLegacyMonitor("cpu/nice", "float", printCPUNice, printCPUNiceInfo, sm);
registerLegacyMonitor("cpu/sys", "float", printCPUSys, printCPUSysInfo, sm);
registerLegacyMonitor("cpu/idle", "float", printCPUIdle, printCPUIdleInfo, sm);
for (id = 0; id < cores; ++id) {
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/user", id);
registerMonitor(name, "float", printCPUxUser, printCPUxUserInfo, sm);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/nice", id);
registerMonitor(name, "float", printCPUxNice, printCPUxNiceInfo, sm);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/sys", id);
registerMonitor(name, "float", printCPUxSys, printCPUxSysInfo, sm);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/TotalLoad", id);
registerMonitor(name, "float", printCPUxTotalLoad, printCPUxTotalLoadInfo, sm);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/intr", id);
registerMonitor(name, "float", printCPUxIntr, printCPUxIntrInfo, sm);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/idle", id);
registerMonitor(name, "float", printCPUxIdle, printCPUxIdleInfo, sm);
}
/*
* CPU frequencies
*/
if ((freq = malloc(sizeof(int) * 3 * (cores + 1))) == NULL) {
log_error("out of memory for freq");
return;
}
registerMonitor("cpu/system/AverageClock", "float", printCPUClock, printCPUClockInfo, sm);
for (id = 0; id < cores; ++id) {
len = sizeof(int);
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.freq", id);
if (!sysctlbyname(name, &freq[id][0], &len, NULL, 0)) {
get_mmfreq(id, &freq[id][1], &freq[id][2]);
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/clock", id);
registerMonitor(name, "integer", printCPUxClock, printCPUxClockInfo, sm);
} else {
freq[id][0] = -1;
freq[id][1] = 0;
freq[id][2] = 0;
}
}
minfreq = freq[0][1];
maxfreq = freq[0][2];
for (id = 1; id < cores; ++id)
if (freq[id][0] != -1) {
minfreq = minfreq > freq[id][1] ? freq[id][1] : minfreq;
maxfreq = maxfreq < freq[id][2] ? freq[id][2] : maxfreq;
}
freq[cores][1] = minfreq;
freq[cores][2] = maxfreq;
/*
* CPU temperature
*/
if ((temp = malloc(sizeof(int) * (cores + 1))) == NULL) {
log_error("out of memory for temp");
return;
}
registerMonitor("cpu/system/AverageTemperature", "float", printCPUTemperature, printCPUTemperatureInfo, sm);
for (id = 0; id < cores; ++id) {
len = sizeof(int);
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.temperature", id);
if (!sysctlbyname(name, &temp[id], &len, NULL, 0)) {
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/temperature", id);
registerMonitor(name, "float", printCPUxTemperature, printCPUxTemperatureInfo, sm);
} else
temp[id] = -1;
}
updateCpuInfo();
}
void getMdadmDetail( ArrayInfo* MyArray ) {
int fd[2];
pid_t ChildPID;
ssize_t nbytes;
char sensorName[128];
char arrayDevice[ARRAYNAMELEN + 5];
char format[ 32 ];
char lineBuf[ 1024 ];
char mdadmStatBuf[ MDADMSTATBUFSIZE ]; /* Buffer for mdadm --detail */
char* mdadmStatBufP;
/* Create a pipe */
if(pipe(fd) == -1)
{
perror("Could not create a pipe to launch mdadm.");
exit(1);
}
/* Fork */
if((ChildPID = fork()) == -1)
{
perror("Could not fork to launch mdadm.");
exit(1);
}
/* Child will execute the program, parent will listen. */
if (ChildPID == 0) {
/* Child process */
/* Child will execute the program, parent will listen. */
/* Close stdout, duplicate the input side of pipe to stdout */
dup2(fd[1], 1);
/* Close output side of pipe */
close(fd[0]);
close(2);
snprintf( arrayDevice, sizeof( arrayDevice ), "/dev/%s", MyArray->ArrayName );
execl ("/sbin/mdadm", "mdadm", "--detail", arrayDevice, (char *)0);
exit(0); /* In case /sbin/mdadm isn't found */
/* Child is now dead, as per our request */
}
/* Parent process */
/* Close input side of pipe */
close(fd[1]);
waitpid( ChildPID, 0, 0);
/* Fill mdadmStatBuf with pipe's output */
nbytes = read( fd[0], mdadmStatBuf, MDADMSTATBUFSIZE-1 );
if (nbytes >= 0)
mdadmStatBuf[nbytes] = '\0';
/* Now, go through mdadmStatBuf line by line. Register monitors along the way */
sprintf( format, "%%%d[^\n]\n", (int)sizeof( lineBuf ) - 1 );
mdadmStatBufP = mdadmStatBuf;
while (sscanf(mdadmStatBufP, format, lineBuf) != EOF) {
lineBuf[sizeof(lineBuf) - 1] = '\0';
mdadmStatBufP += strlen(lineBuf) + 1; /* move mdadmStatBufP to next line */
if ( sscanf(lineBuf, " Array Size : %d", &MyArray->ArraySizeKB) == 1 ) {
MyArray->ArraySizeIsAlive = true;
if ( !MyArray->ArraySizeIsRegistered ) {
sprintf(sensorName, "SoftRaid/%s/ArraySizeKB", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
MyArray->ArraySizeIsRegistered = true;
}
}
/* Versions of mdadm prior to 2.6 used "Device Size" instead of "Used Dev Size"
*/
else if ( ( sscanf(lineBuf, " Device Size : %d", &MyArray->UsedDeviceSizeKB) == 1 ) ||
( sscanf(lineBuf, " Used Dev Size : %d", &MyArray->UsedDeviceSizeKB) == 1 ) ) {
MyArray->UsedDeviceSizeIsAlive = true;
if ( !MyArray->UsedDeviceSizeIsRegistered ) {
sprintf(sensorName, "SoftRaid/%s/UsedDeviceSizeKB", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
MyArray->UsedDeviceSizeIsRegistered = true;
}
}
else if ( sscanf(lineBuf, "Preferred Minor : %d", &MyArray->PreferredMinor) == 1 ) {
MyArray->PreferredMinorIsAlive = true;
if ( !MyArray->PreferredMinorIsRegistered ) {
sprintf(sensorName, "SoftRaid/%s/PreferredMinor", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
MyArray->PreferredMinorIsRegistered = true;
}
}
}
/* Note: Don't test NumBlocksIsAlive, because it hasn't been set yet */
if ( (!MyArray->ArraySizeIsAlive && MyArray->ArraySizeIsRegistered ) ||
(!MyArray->UsedDeviceSizeIsAlive && MyArray->UsedDeviceSizeIsRegistered ) ||
(!MyArray->PreferredMinorIsAlive && MyArray->PreferredMinorIsRegistered )
) {
print_error( "RECONFIGURE" );
log_error( "Soft raid device disappeared" );
return;
}
}
ArrayInfo *getOrCreateArrayInfo(char *array_name, int array_name_length) {
ArrayInfo key;
INDEX idx;
ArrayInfo* MyArray;
/*We have the array name. see if we already have a record for it*/
strncpy(key.ArrayName, array_name, array_name_length);
key.ArrayName[array_name_length]='\0';
if ( ( idx = search_ctnr( ArrayInfos, ArrayInfoEqual, &key ) ) == 0 ) {
/* Found an existing array device */
MyArray = get_ctnr( ArrayInfos, idx );
}
else {
/* Found a new array device. Create a data structure for it. */
MyArray = calloc(1,sizeof (ArrayInfo));
if (MyArray == NULL) {
/* Memory could not be allocated, so print an error and exit. */
fprintf(stderr, "Could not allocate memory\n");
exit(EXIT_FAILURE);
}
strcpy( MyArray->ArrayName, key.ArrayName );
/* Add this array to our list of array devices */
push_ctnr(ArrayInfos, MyArray);
char sensorName[128];
sprintf(sensorName, "SoftRaid/%s/NumBlocks", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/TotalDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/FailedDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/SpareDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/NumRaidDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/WorkingDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/ActiveDevices", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/RaidType", MyArray->ArrayName);
registerMonitor(sensorName, "string", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/DeviceNumber", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/ResyncingPercent", MyArray->ArrayName);
registerMonitor(sensorName, "integer", printArrayAttribute, printArrayAttributeInfo, StatSM );
sprintf(sensorName, "SoftRaid/%s/DiskInfo", MyArray->ArrayName);
registerMonitor(sensorName, "listview", printArrayAttribute, printArrayAttributeInfo, StatSM );
}
return MyArray;
}
void initStat( struct SensorModul* sm ) {
/* The CPU load is calculated from the values in /proc/stat. The cpu
* entry contains 7 counters. These counters count the number of ticks
* the system has spend on user processes, system processes, nice
* processes, idle and IO-wait time, hard and soft interrupts.
*
* SMP systems will have cpu1 to cpuN lines right after the cpu info. The
* format is identical to cpu and reports the information for each cpu.
* Linux kernels <= 2.0 do not provide this information!
*
* The /proc/stat file looks like this:
*
* cpu <user> <nice> <system> <idling> <waiting> <hardinterrupt> <softinterrupt>
* disk 7797 0 0 0
* disk_rio 6889 0 0 0
* disk_wio 908 0 0 0
* disk_rblk 13775 0 0 0
* disk_wblk 1816 0 0 0
* page 27575 1330
* swap 1 0
* intr 50444 38672 2557 0 0 0 0 2 0 2 0 0 3 1429 1 7778 0
* ctxt 54155
* btime 917379184
* processes 347
*
* Linux kernel >= 2.4.0 have one or more disk_io: lines instead of
* the disk_* lines.
*
* Linux kernel >= 2.6.x(?) have disk I/O stats in /proc/diskstats
* and no disk relevant lines are found in /proc/stat
*/
char format[ 32 ];
char tagFormat[ 16 ];
char buf[ 1024 ];
char tag[ 32 ];
StatSM = sm;
sprintf( format, "%%%d[^\n]\n", (int)sizeof( buf ) - 1 );
sprintf( tagFormat, "%%%ds", (int)sizeof( tag ) - 1 );
FILE *stat = fopen("/proc/stat", "r");
if(!stat) {
print_error( "Cannot open file \'/proc/stat\'!\n"
"The kernel needs to be compiled with support\n"
"for /proc file system enabled!\n" );
return;
}
while ( fscanf( stat, format, buf ) == 1 ) {
buf[ sizeof( buf ) - 1 ] = '\0';
sscanf( buf, tagFormat, tag );
if ( strcmp( "cpu", tag ) == 0 ) {
/* Total CPU load */
registerMonitor( "cpu/system/user", "float", printCPUUser, printCPUUserInfo, StatSM );
registerMonitor( "cpu/system/nice", "float", printCPUNice, printCPUNiceInfo, StatSM );
registerMonitor( "cpu/system/sys", "float", printCPUSys, printCPUSysInfo, StatSM );
registerMonitor( "cpu/system/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, StatSM );
registerMonitor( "cpu/system/idle", "float", printCPUIdle, printCPUIdleInfo, StatSM );
registerMonitor( "cpu/system/wait", "float", printCPUWait, printCPUWaitInfo, StatSM );
/* Monitor names changed from kde3 => kde4. Remain compatible with legacy requests when possible. */
registerLegacyMonitor( "cpu/user", "float", printCPUUser, printCPUUserInfo, StatSM );
registerLegacyMonitor( "cpu/nice", "float", printCPUNice, printCPUNiceInfo, StatSM );
registerLegacyMonitor( "cpu/sys", "float", printCPUSys, printCPUSysInfo, StatSM );
registerLegacyMonitor( "cpu/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, StatSM );
registerLegacyMonitor( "cpu/idle", "float", printCPUIdle, printCPUIdleInfo, StatSM );
registerLegacyMonitor( "cpu/wait", "float", printCPUWait, printCPUWaitInfo, StatSM );
}
else if ( strncmp( "cpu", tag, 3 ) == 0 ) {
char cmdName[ 24 ];
/* Load for each SMP CPU */
int id;
sscanf( tag + 3, "%d", &id );
CPUCount++;
sprintf( cmdName, "cpu/cpu%d/user", id );
registerMonitor( cmdName, "float", printCPUxUser, printCPUxUserInfo, StatSM );
sprintf( cmdName, "cpu/cpu%d/nice", id );
registerMonitor( cmdName, "float", printCPUxNice, printCPUxNiceInfo, StatSM );
sprintf( cmdName, "cpu/cpu%d/sys", id );
registerMonitor( cmdName, "float", printCPUxSys, printCPUxSysInfo, StatSM );
sprintf( cmdName, "cpu/cpu%d/TotalLoad", id );
registerMonitor( cmdName, "float", printCPUxTotalLoad, printCPUxTotalLoadInfo, StatSM );
sprintf( cmdName, "cpu/cpu%d/idle", id );
registerMonitor( cmdName, "float", printCPUxIdle, printCPUxIdleInfo, StatSM );
sprintf( cmdName, "cpu/cpu%d/wait", id );
registerMonitor( cmdName, "float", printCPUxWait, printCPUxWaitInfo, StatSM );
}
else if ( strcmp( "disk", tag ) == 0 ) {
unsigned long val;
char* b = buf + 5;
/* Count the number of registered disks */
for ( DiskCount = 0; *b && sscanf( b, "%lu", &val ) == 1; DiskCount++ ) {
while ( *b && isblank( *b++ ) );
while ( *b && isdigit( *b++ ) );
}
if ( DiskCount > 0 )
DiskLoad = (DiskLoadInfo*)malloc( sizeof( DiskLoadInfo ) * DiskCount );
initStatDisk( tag, buf, "disk", "disk", 0, print24DiskTotal, print24DiskTotalInfo );
}
else if ( initStatDisk( tag, buf, "disk_rio", "rio", 1, print24DiskRIO, print24DiskRIOInfo ) );
else if ( initStatDisk( tag, buf, "disk_wio", "wio", 2, print24DiskWIO, print24DiskWIOInfo ) );
else if ( initStatDisk( tag, buf, "disk_rblk", "rblk", 3, print24DiskRBlk, print24DiskRBlkInfo ) );
else if ( initStatDisk( tag, buf, "disk_wblk", "wblk", 4, print24DiskWBlk, print24DiskWBlkInfo ) );
else if ( strcmp( "disk_io:", tag ) == 0 )
process24DiskIO( buf );
else if ( strcmp( "page", tag ) == 0 ) {
sscanf( buf + 5, "%lu %lu", &OldPageIn, &OldPageOut );
registerMonitor( "cpu/pageIn", "float", printPageIn, printPageInInfo, StatSM );
registerMonitor( "cpu/pageOut", "float", printPageOut, printPageOutInfo, StatSM );
}
else if ( strcmp( "intr", tag ) == 0 ) {
unsigned int i;
char cmdName[ 32 ];
char* p = buf + 5;
/* Count the number of listed values in the intr line. */
NumOfInts = 0;
while ( *p )
if ( *p++ == ' ' )
NumOfInts++;
/* It looks like anything above 24 is always 0. So let's just
* ignore this for the time being. */
if ( NumOfInts > 25 )
NumOfInts = 25;
OldIntr = (unsigned long*)malloc( NumOfInts * sizeof( unsigned long ) );
Intr = (unsigned long*)malloc( NumOfInts * sizeof( unsigned long ) );
i = 0;
p = buf + 5;
for ( i = 0; p && i < NumOfInts; i++ ) {
sscanf( p, "%lu", &OldIntr[ i ] );
while ( *p && *p != ' ' )
p++;
while ( *p && *p == ' ' )
p++;
sprintf( cmdName, "cpu/interrupts/int%02d", i );
registerMonitor( cmdName, "float", printInterruptx, printInterruptxInfo, StatSM );
}
}
else if ( strcmp( "ctxt", tag ) == 0 ) {
sscanf( buf + 5, "%lu", &OldCtxt );
registerMonitor( "cpu/context", "float", printCtxt, printCtxtInfo, StatSM );
}
}
fclose(stat);
stat = fopen("/proc/vmstat", "r");
if(!stat) {
print_error( "Cannot open file \'/proc/vmstat\'\n");
} else {
while ( fscanf( stat, format, buf ) == 1 ) {
buf[ sizeof( buf ) - 1 ] = '\0';
sscanf( buf, tagFormat, tag );
if ( strcmp( "pgpgin", tag ) == 0 ) {
sscanf( buf + 7, "%lu", &OldPageIn );
registerMonitor( "cpu/pageIn", "float", printPageIn, printPageInInfo, StatSM );
}
else if ( strcmp( "pgpgout", tag ) == 0 ) {
sscanf( buf + 7, "%lu", &OldPageOut );
registerMonitor( "cpu/pageOut", "float", printPageOut, printPageOutInfo, StatSM );
}
}
fclose(stat);
}
if ( CPUCount > 0 )
SMPLoad = (CPULoadInfo*)calloc( CPUCount, sizeof( CPULoadInfo ) );
/* Call processStat to eliminate initial peek values. */
processStat();
}
void initNetDev( struct SensorModul* sm ) {
#ifdef HAVE_KSTAT
char mon[128];
int i;
getnetdevlist();
for( i = 0; i < NetDevCount; i++ ) {
sprintf( mon, "network/%s/ipackets", IfInfo[i].Name );
registerMonitor( mon, "integer",
printIPackets, printIPacketsInfo, sm );
sprintf( mon, "network/%s/opackets", IfInfo[i].Name );
registerMonitor( mon, "integer",
printOPackets, printOPacketsInfo, sm );
/*
* if this isn't a loopback interface,
* register additional monitors
*/
if( ! (IfInfo[i].flags & IFF_LOOPBACK) ) {
/*
* recv errors
*/
sprintf( mon, "network/%s/ierrors",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printIErrors, printIErrorsInfo, sm );
/*
* xmit errors
*/
sprintf( mon, "network/%s/oerrors",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printOErrors, printOErrorsInfo, sm );
/*
* collisions
*/
sprintf( mon, "network/%s/collisions",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printCollisions, printCollisionsInfo, sm );
/*
* multicast xmits
*/
sprintf( mon, "network/%s/multixmt",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printMultiXmits, printMultiXmitsInfo, sm );
/*
* multicast recvs
*/
sprintf( mon, "network/%s/multircv",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printMultiRecvs, printMultiRecvsInfo, sm );
/*
* broadcast xmits
*/
sprintf( mon, "network/%s/brdcstxmt",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printBcastXmits, printBcastXmitsInfo, sm );
/*
* broadcast recvs
*/
sprintf( mon, "network/%s/brdcstrcv",
IfInfo[i].Name );
registerMonitor( mon, "integer",
printBcastRecvs, printBcastRecvsInfo, sm );
}
}
#endif
}
