mirror of
https://bitbucket.org/smil3y/kde-workspace.git
synced 2025-02-24 10:52:51 +00:00
386 lines
12 KiB
C
386 lines
12 KiB
C
/*
|
|
KSysGuard, the KDE System Guard
|
|
|
|
Copyright (c) 2001 Tobias Koenig <tokoe@kde.org>
|
|
|
|
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/param.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/ucred.h>
|
|
#include <sys/mount.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#include "Command.h"
|
|
#include "ccont.h"
|
|
#include "diskstat.h"
|
|
#include "ksysguardd.h"
|
|
|
|
typedef struct {
|
|
char device[256];
|
|
char mntpnt[256];
|
|
long blocks;
|
|
long bfree;
|
|
long bused;
|
|
int bused_percent;
|
|
long bsize;
|
|
long files;
|
|
long ffree;
|
|
long fused;
|
|
int fused_percent;
|
|
} DiskInfo;
|
|
|
|
#define BLK2KB(disk_info, prop) \
|
|
(disk_info->prop * (disk_info->bsize / 1024))
|
|
|
|
#define MNTPNT_NAME(disk_info) \
|
|
(strcmp(disk_info->mntpnt, "/root") ? disk_info->mntpnt : "/")
|
|
|
|
static CONTAINER DiskStatList = 0;
|
|
static struct SensorModul* DiskStatSM;
|
|
|
|
char *getMntPnt(const char *cmd)
|
|
{
|
|
static char device[1025];
|
|
char *ptr;
|
|
|
|
memset(device, 0, sizeof(device));
|
|
sscanf(cmd, "partitions%1024s", device);
|
|
|
|
ptr = (char *)rindex(device, '/');
|
|
*ptr = '\0';
|
|
|
|
return (char *)device;
|
|
}
|
|
|
|
int numMntPnt(void)
|
|
{
|
|
struct statfs *fs_info;
|
|
int i, n, counter = 0;
|
|
|
|
n = getmntinfo(&fs_info, MNT_WAIT);
|
|
for (i = 0; i < n; i++)
|
|
if (strcmp(fs_info[i].f_fstypename, "procfs") && strcmp(fs_info[i].f_fstypename, "swap") && strcmp(fs_info[i].f_fstypename, "devfs"))
|
|
counter++;
|
|
|
|
return counter;
|
|
}
|
|
|
|
/* ------------------------------ public part --------------------------- */
|
|
|
|
void initDiskStat(struct SensorModul* sm)
|
|
{
|
|
char monitor[1024];
|
|
DiskInfo* disk_info;
|
|
|
|
DiskStatList = new_ctnr();
|
|
DiskStatSM = sm;
|
|
|
|
updateDiskStat();
|
|
|
|
registerMonitor("partitions/list", "listview", printDiskStat, printDiskStatInfo, DiskStatSM);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/usedspace", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatUsed, printDiskStatUsedInfo, DiskStatSM);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/freespace", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatFree, printDiskStatFreeInfo, DiskStatSM);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/filllevel", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatPercent, printDiskStatPercentInfo, DiskStatSM);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/usedinode", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatIUsed, printDiskStatIUsedInfo, DiskStatSM);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/freeinode", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatIFree, printDiskStatIFreeInfo, DiskStatSM);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/inodelevel", disk_info->mntpnt);
|
|
registerMonitor(monitor, "integer", printDiskStatIPercent, printDiskStatIPercentInfo, DiskStatSM);
|
|
}
|
|
}
|
|
|
|
void checkDiskStat(void)
|
|
{
|
|
if (numMntPnt() != level_ctnr(DiskStatList)) {
|
|
/* a file system was mounted or unmounted
|
|
so we do a reset */
|
|
exitDiskStat();
|
|
initDiskStat(DiskStatSM);
|
|
}
|
|
}
|
|
|
|
void exitDiskStat(void)
|
|
{
|
|
DiskInfo *disk_info;
|
|
char monitor[1024];
|
|
|
|
removeMonitor("partitions/list");
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/usedspace", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/freespace", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/filllevel", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/usedinode", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/freeinode", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
snprintf(monitor, sizeof(monitor), "partitions%s/inodelevel", disk_info->mntpnt);
|
|
removeMonitor(monitor);
|
|
}
|
|
|
|
destr_ctnr(DiskStatList, free);
|
|
}
|
|
|
|
int updateDiskStat(void)
|
|
{
|
|
struct statfs *fs_info;
|
|
struct statfs fs;
|
|
float percent, fpercent;
|
|
int i, mntcount;
|
|
DiskInfo *disk_info;
|
|
|
|
/* let's hope there is no difference between the DiskStatList and
|
|
the number of mounted file systems */
|
|
empty_ctnr(DiskStatList);
|
|
|
|
mntcount = getmntinfo(&fs_info, MNT_WAIT);
|
|
|
|
for (i = 0; i < mntcount; i++) {
|
|
fs = fs_info[i];
|
|
if (strcmp(fs.f_fstypename, "procfs") && strcmp(fs.f_fstypename, "devfs") && strcmp(fs.f_fstypename, "linprocfs")) {
|
|
if ( fs.f_blocks != 0 )
|
|
percent = (((float)fs.f_blocks - (float)fs.f_bfree)*100.0/(float)fs.f_blocks);
|
|
else
|
|
percent = 0;
|
|
if (fs.f_files != 0)
|
|
fpercent = (((float)fs.f_files - (float)fs.f_ffree)*100.0/(float)fs.f_files);
|
|
else
|
|
fpercent = 0;
|
|
if ((disk_info = (DiskInfo *)malloc(sizeof(DiskInfo))) == NULL)
|
|
continue;
|
|
memset(disk_info, 0, sizeof(DiskInfo));
|
|
strlcpy(disk_info->device, fs.f_mntfromname, sizeof(disk_info->device));
|
|
if (!strcmp(fs.f_mntonname, "/"))
|
|
strncpy(disk_info->mntpnt, "/root", 6);
|
|
else
|
|
strlcpy(disk_info->mntpnt, fs.f_mntonname, sizeof(disk_info->mntpnt));
|
|
disk_info->blocks = fs.f_blocks;
|
|
disk_info->bfree = fs.f_bfree;
|
|
disk_info->bused = (fs.f_blocks - fs.f_bfree);
|
|
disk_info->bused_percent = (int)percent;
|
|
disk_info->bsize = fs.f_bsize;
|
|
push_ctnr(DiskStatList, disk_info);
|
|
disk_info->files = fs.f_files;
|
|
disk_info->ffree = fs.f_ffree;
|
|
disk_info->fused = fs.f_files - fs.f_ffree;
|
|
disk_info->fused_percent = (int)fpercent;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void printDiskStat(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
fprintf(CurrentClient, "%s\t%ld\t%ld\t%ld\t%d\t%ld\t%ld\t%ld\t%d\t%s\n",
|
|
disk_info->device,
|
|
BLK2KB(disk_info, blocks),
|
|
BLK2KB(disk_info, bused),
|
|
BLK2KB(disk_info, bfree),
|
|
disk_info->bused_percent,
|
|
disk_info->files,
|
|
disk_info->fused,
|
|
disk_info->ffree,
|
|
disk_info->fused_percent,
|
|
MNTPNT_NAME(disk_info));
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "Device\tCapacity\tUsed\tAvailable\tUsed %%\tInodes\tUsed Inodes\tFree Inodes\tInodes %%\tMountPoint\nM\tKB\tKB\tKB\t%%\td\td\td\t%%\ts\n");
|
|
}
|
|
|
|
void printDiskStatUsed(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%ld\n", BLK2KB(disk_info, bused));
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatUsedInfo(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "Used Space (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), BLK2KB(disk_info, blocks));
|
|
return;
|
|
}
|
|
}
|
|
fprintf(CurrentClient, "Used Space (%s)\t0\t-\tKB\n", mntpnt);
|
|
}
|
|
|
|
void printDiskStatFree(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%ld\n", BLK2KB(disk_info, bfree));
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatFreeInfo(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "Free Space (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), BLK2KB(disk_info, blocks));
|
|
return;
|
|
}
|
|
}
|
|
fprintf(CurrentClient, "Free Space (%s)\t0\t-\tKB\n", mntpnt);
|
|
}
|
|
|
|
void printDiskStatPercent(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%d\n", disk_info->bused_percent);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatPercentInfo(const char* cmd)
|
|
{
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
fprintf(CurrentClient, "Used Space (%s)\t0\t100\t%%\n", mntpnt);
|
|
}
|
|
|
|
void printDiskStatIUsed(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%ld\n", disk_info->fused);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatIUsedInfo(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "Used Inodes (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), disk_info->files);
|
|
return;
|
|
}
|
|
}
|
|
fprintf(CurrentClient, "Used Inodes(%s)\t0\t-\tKB\n", mntpnt);
|
|
}
|
|
|
|
void printDiskStatIFree(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%ld\n", disk_info->ffree);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatIFreeInfo(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "Free Inodes (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), disk_info->files);
|
|
return;
|
|
}
|
|
}
|
|
fprintf(CurrentClient, "Free Inodes (%s)\t0\t-\tKB\n", mntpnt);
|
|
}
|
|
|
|
void printDiskStatIPercent(const char* cmd)
|
|
{
|
|
DiskInfo* disk_info;
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
|
|
if (!strcmp(mntpnt, disk_info->mntpnt)) {
|
|
fprintf(CurrentClient, "%d\n", disk_info->fused_percent);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fprintf(CurrentClient, "\n");
|
|
}
|
|
|
|
void printDiskStatIPercentInfo(const char* cmd)
|
|
{
|
|
char *mntpnt = (char *)getMntPnt(cmd);
|
|
|
|
fprintf(CurrentClient, "Used Inodes (%s)\t0\t100\t%%\n", mntpnt);
|
|
}
|
|
|