You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
263 lines
6.2 KiB
263 lines
6.2 KiB
/*
|
|
KSysGuard, the KDE System Guard
|
|
|
|
Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
|
|
|
|
Irix support by Carsten Kroll <ckroll@pinnaclesys.com>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/sysmp.h>
|
|
#include <sys/sysinfo.h>
|
|
|
|
#include "cpu.h"
|
|
#include "Command.h"
|
|
#include "ksysguardd.h"
|
|
|
|
#define CPUSTATES 6
|
|
|
|
long percentages(int cnt, int *out, long *new, long *old, long *diffs);
|
|
|
|
static int nCPUs=0;
|
|
|
|
|
|
long cp_time[CPUSTATES];
|
|
long cp_old[CPUSTATES];
|
|
long cp_diff[CPUSTATES];
|
|
int cpu_states[CPUSTATES];
|
|
|
|
struct cpu_info{
|
|
long cp_time[CPUSTATES];
|
|
long cp_old[CPUSTATES];
|
|
long cp_diff[CPUSTATES];
|
|
int cpu_states[CPUSTATES];
|
|
};
|
|
|
|
static struct cpu_info *g_ci;
|
|
|
|
/* returns the requested cpu number starting at 0*/
|
|
int getID(const char *cmd){
|
|
int id;
|
|
sscanf(cmd + 7, "%d", &id);
|
|
return id-1;
|
|
}
|
|
|
|
void
|
|
initCpuInfo(struct SensorModul* sm)
|
|
{
|
|
char mname[50];
|
|
int i;
|
|
if (sysmp(MP_NPROCS,&nCPUs) < 0) nCPUs=0;
|
|
nCPUs++;
|
|
g_ci = malloc(sizeof(struct cpu_info) * nCPUs);
|
|
memset(g_ci,0,sizeof(struct cpu_info) * nCPUs);
|
|
|
|
registerMonitor("cpu/user", "integer", printCPUUser,
|
|
printCPUUserInfo, sm);
|
|
registerMonitor("cpu/sys", "integer", printCPUSys,
|
|
printCPUSysInfo, sm);
|
|
registerMonitor("cpu/idle", "integer", printCPUIdle,
|
|
printCPUIdleInfo, sm);
|
|
|
|
if (nCPUs > 1) for (i=0;i<nCPUs;i++){
|
|
/* indidividual CPU load */
|
|
sprintf(mname,"cpu/cpu%d/user",i+1);
|
|
registerMonitor(mname, "integer", printCPUxUser,
|
|
printCPUUserInfo, sm);
|
|
sprintf(mname,"cpu/cpu%d/sys",i+1);
|
|
registerMonitor(mname, "integer", printCPUxSys,
|
|
printCPUSysInfo, sm);
|
|
sprintf(mname,"cpu/cpu%d/idle",i+1);
|
|
registerMonitor(mname, "integer", printCPUxIdle,
|
|
printCPUIdleInfo, sm);
|
|
}
|
|
|
|
updateCpuInfo();
|
|
}
|
|
|
|
void
|
|
exitCpuInfo(void)
|
|
{
|
|
free(g_ci);
|
|
}
|
|
|
|
int
|
|
updateCpuInfo(void)
|
|
{
|
|
struct sysinfo si;
|
|
int rv=0;
|
|
int i;
|
|
/* overall summary */
|
|
if (sysmp(MP_SAGET,MPSA_SINFO,&si,sizeof(struct sysinfo)) >=0){
|
|
cp_time[CPU_IDLE] =si.cpu[CPU_IDLE];
|
|
cp_time[CPU_USER] =si.cpu[CPU_USER];
|
|
cp_time[CPU_KERNEL]=si.cpu[CPU_KERNEL];
|
|
cp_time[CPU_SXBRK] =si.cpu[CPU_SXBRK];
|
|
cp_time[CPU_INTR] =si.cpu[CPU_INTR];
|
|
cp_time[CPU_WAIT] =si.cpu[CPU_WAIT];
|
|
percentages(CPUSTATES,cpu_states,cp_time,cp_old,cp_diff);
|
|
}
|
|
/* individual CPU statistics*/
|
|
if (nCPUs > 1) for (i=0;i<nCPUs;i++){
|
|
if (sysmp(MP_SAGET1,MPSA_SINFO,&si,sizeof(struct sysinfo),i) >=0){
|
|
g_ci[i].cp_time[CPU_IDLE] =si.cpu[CPU_IDLE];
|
|
g_ci[i].cp_time[CPU_USER] =si.cpu[CPU_USER];
|
|
g_ci[i].cp_time[CPU_KERNEL]=si.cpu[CPU_KERNEL];
|
|
g_ci[i].cp_time[CPU_SXBRK] =si.cpu[CPU_SXBRK];
|
|
g_ci[i].cp_time[CPU_INTR] =si.cpu[CPU_INTR];
|
|
g_ci[i].cp_time[CPU_WAIT] =si.cpu[CPU_WAIT];
|
|
percentages(CPUSTATES, g_ci[i].cpu_states, g_ci[i].cp_time, g_ci[i].cp_old,g_ci[i].cp_diff);
|
|
}else{
|
|
rv =-1;
|
|
}
|
|
}
|
|
return (rv);
|
|
}
|
|
|
|
void
|
|
printCPUUser(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", cpu_states[CPU_USER]/10);
|
|
}
|
|
|
|
void
|
|
printCPUUserInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU User Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUSys(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", cpu_states[CPU_KERNEL]/10);
|
|
}
|
|
|
|
void
|
|
printCPUSysInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU System Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUIdle(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", cpu_states[CPU_IDLE]/10);
|
|
}
|
|
|
|
void
|
|
printCPUIdleInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Idle Load\t0\t100\t%%\n");
|
|
}
|
|
/* same as above but for individual CPUs */
|
|
void
|
|
printCPUxUser(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", g_ci[getID(cmd)].cpu_states[CPU_USER]/10);
|
|
}
|
|
|
|
void
|
|
printCPUxSys(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", g_ci[getID(cmd)].cpu_states[CPU_KERNEL]/10);
|
|
}
|
|
|
|
void
|
|
printCPUxIdle(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", g_ci[getID(cmd)].cpu_states[CPU_IDLE]/10);
|
|
}
|
|
|
|
|
|
/* The part ripped from top... */
|
|
/*
|
|
* Top users/processes display for Unix
|
|
* Version 3
|
|
*
|
|
* This program may be freely redistributed,
|
|
* but this entire comment MUST remain intact.
|
|
*
|
|
* Copyright (c) 1984, 1989, William LeFebvre, Rice University
|
|
* Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University
|
|
*/
|
|
|
|
/*
|
|
* percentages(cnt, out, new, old, diffs) - calculate percentage change
|
|
* between array "old" and "new", putting the percentages in "out".
|
|
* "cnt" is size of each array and "diffs" is used for scratch space.
|
|
* The array "old" is updated on each call.
|
|
* The routine assumes modulo arithmetic. This function is especially
|
|
* useful on BSD mchines for calculating cpu state percentages.
|
|
*/
|
|
|
|
long percentages(cnt, out, new, old, diffs)
|
|
|
|
int cnt;
|
|
int *out;
|
|
long *new;
|
|
long *old;
|
|
long *diffs;
|
|
|
|
{
|
|
int i;
|
|
long change;
|
|
long total_change;
|
|
long *dp;
|
|
long half_total;
|
|
|
|
/* initialization */
|
|
total_change = 0;
|
|
dp = diffs;
|
|
|
|
/* calculate changes for each state and the overall change */
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
if ((change = *new - *old) < 0)
|
|
{
|
|
/* this only happens when the counter wraps */
|
|
change = (int)
|
|
((unsigned long)*new-(unsigned long)*old);
|
|
}
|
|
total_change += (*dp++ = change);
|
|
*old++ = *new++;
|
|
}
|
|
|
|
/* avoid divide by zero potential */
|
|
if (total_change == 0)
|
|
{
|
|
total_change = 1;
|
|
}
|
|
|
|
/* calculate percentages based on overall change, rounding up */
|
|
half_total = total_change / 2l;
|
|
|
|
/* Do not divide by 0. Causes Floating point exception */
|
|
if(total_change) {
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
*out++ = (int)((*diffs++ * 1000 + half_total) / total_change);
|
|
}
|
|
}
|
|
|
|
/* return the total in case the caller wants to use it */
|
|
return(total_change);
|
|
}
|