← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kde-workspace/utopic-proposed

« back to all changes in this revision

Viewing changes to ksysguard/ksysguardd/FreeBSD/diskstat.c

  • Committer: Bazaar Package Importer
  • Author(s): Michał Zając
  • Date: 2011-07-09 08:31:15 UTC
  • Revision ID: james.westby@ubuntu.com-20110709083115-ohyxn6z93mily9fc
Tags: upstream-4.6.90
Import upstream version 4.6.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
ksysguard/ksysguardd/FreeBSD/diskstat.c
 
1
/*
 
2
    KSysGuard, the KDE System Guard
 
3
 
 
4
    Copyright (c) 2001 Tobias Koenig <tokoe@kde.org>
 
5
 
 
6
    This program is free software; you can redistribute it and/or
 
7
    modify it under the terms of the GNU General Public
 
8
    License as published by the Free Software Foundation; either
 
9
    version 2 of the License, or (at your option) any later version.
 
10
 
 
11
    This program is distributed in the hope that it will be useful,
 
12
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
    GNU General Public License for more details.
 
15
 
 
16
    You should have received a copy of the GNU General Public License
 
17
    along with this program; if not, write to the Free Software
 
18
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
19
 
 
20
*/
 
21
 
 
22
#include <stdio.h>
 
23
#include <stdlib.h>
 
24
#include <string.h>
 
25
#include <sys/param.h>
 
26
#include <sys/stat.h>
 
27
#include <sys/ucred.h>
 
28
#include <sys/mount.h>
 
29
#include <time.h>
 
30
#include <unistd.h>
 
31
 
 
32
#include "Command.h"
 
33
#include "ccont.h"
 
34
#include "diskstat.h"
 
35
#include "ksysguardd.h"
 
36
 
 
37
typedef struct {
 
38
    char device[256];
 
39
    char mntpnt[256];
 
40
    long blocks;
 
41
    long bfree;
 
42
    long bused;
 
43
    int bused_percent;
 
44
    long bsize;
 
45
    long files;
 
46
    long ffree;
 
47
    long fused;
 
48
    int fused_percent;
 
49
} DiskInfo;
 
50
 
 
51
#define BLK2KB(disk_info, prop)                        \
 
52
    (disk_info->prop * (disk_info->bsize / 1024))
 
53
 
 
54
#define MNTPNT_NAME(disk_info)                        \
 
55
    (strcmp(disk_info->mntpnt, "/root") ? disk_info->mntpnt : "/")
 
56
 
 
57
static CONTAINER DiskStatList = 0;
 
58
static struct SensorModul* DiskStatSM;
 
59
 
 
60
char *getMntPnt(const char *cmd)
 
61
{
 
62
    static char device[1025];
 
63
    char *ptr;
 
64
 
 
65
    memset(device, 0, sizeof(device));
 
66
    sscanf(cmd, "partitions%1024s", device);
 
67
 
 
68
    ptr = (char *)rindex(device, '/');
 
69
    *ptr = '\0';
 
70
 
 
71
    return (char *)device;
 
72
}
 
73
 
 
74
int numMntPnt(void)
 
75
{
 
76
    struct statfs *fs_info;
 
77
    int i, n, counter = 0;
 
78
 
 
79
    n = getmntinfo(&fs_info, MNT_WAIT);
 
80
    for (i = 0; i < n; i++)
 
81
        if (strcmp(fs_info[i].f_fstypename, "procfs") && strcmp(fs_info[i].f_fstypename, "swap") && strcmp(fs_info[i].f_fstypename, "devfs"))
 
82
            counter++;
 
83
 
 
84
    return counter;
 
85
}
 
86
 
 
87
/* ------------------------------ public part --------------------------- */
 
88
 
 
89
void initDiskStat(struct SensorModul* sm)
 
90
{
 
91
    char monitor[1024];
 
92
    DiskInfo* disk_info;
 
93
 
 
94
    DiskStatList = new_ctnr();
 
95
    DiskStatSM = sm;
 
96
 
 
97
    updateDiskStat();
 
98
 
 
99
    registerMonitor("partitions/list", "listview", printDiskStat, printDiskStatInfo, DiskStatSM);
 
100
 
 
101
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
102
        snprintf(monitor, sizeof(monitor), "partitions%s/usedspace", disk_info->mntpnt);
 
103
        registerMonitor(monitor, "integer", printDiskStatUsed, printDiskStatUsedInfo, DiskStatSM);
 
104
        snprintf(monitor, sizeof(monitor), "partitions%s/freespace", disk_info->mntpnt);
 
105
        registerMonitor(monitor, "integer", printDiskStatFree, printDiskStatFreeInfo, DiskStatSM);
 
106
        snprintf(monitor, sizeof(monitor), "partitions%s/filllevel", disk_info->mntpnt);
 
107
        registerMonitor(monitor, "integer", printDiskStatPercent, printDiskStatPercentInfo, DiskStatSM);
 
108
        snprintf(monitor, sizeof(monitor), "partitions%s/usedinode", disk_info->mntpnt);
 
109
        registerMonitor(monitor, "integer", printDiskStatIUsed, printDiskStatIUsedInfo, DiskStatSM);
 
110
        snprintf(monitor, sizeof(monitor), "partitions%s/freeinode", disk_info->mntpnt);
 
111
        registerMonitor(monitor, "integer", printDiskStatIFree, printDiskStatIFreeInfo, DiskStatSM);
 
112
        snprintf(monitor, sizeof(monitor), "partitions%s/inodelevel", disk_info->mntpnt);
 
113
        registerMonitor(monitor, "integer", printDiskStatIPercent, printDiskStatIPercentInfo, DiskStatSM);
 
114
    }
 
115
}
 
116
 
 
117
void checkDiskStat(void)
 
118
{
 
119
    if (numMntPnt() != level_ctnr(DiskStatList)) {
 
120
        /* a file system was mounted or unmounted
 
121
           so we do a reset */
 
122
        exitDiskStat();
 
123
        initDiskStat(DiskStatSM);
 
124
    }
 
125
}
 
126
 
 
127
void exitDiskStat(void)
 
128
{
 
129
    DiskInfo *disk_info;
 
130
    char monitor[1024];
 
131
 
 
132
    removeMonitor("partitions/list");
 
133
 
 
134
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
135
        snprintf(monitor, sizeof(monitor), "partitions%s/usedspace", disk_info->mntpnt);
 
136
        removeMonitor(monitor);
 
137
        snprintf(monitor, sizeof(monitor), "partitions%s/freespace", disk_info->mntpnt);
 
138
        removeMonitor(monitor);
 
139
        snprintf(monitor, sizeof(monitor), "partitions%s/filllevel", disk_info->mntpnt);
 
140
        removeMonitor(monitor);
 
141
        snprintf(monitor, sizeof(monitor), "partitions%s/usedinode", disk_info->mntpnt);
 
142
        removeMonitor(monitor);
 
143
        snprintf(monitor, sizeof(monitor), "partitions%s/freeinode", disk_info->mntpnt);
 
144
        removeMonitor(monitor);
 
145
        snprintf(monitor, sizeof(monitor), "partitions%s/inodelevel", disk_info->mntpnt);
 
146
        removeMonitor(monitor);
 
147
    }
 
148
 
 
149
    destr_ctnr(DiskStatList, free);
 
150
}
 
151
 
 
152
int updateDiskStat(void)
 
153
{
 
154
    struct statfs *fs_info;
 
155
    struct statfs fs;
 
156
    float percent, fpercent;
 
157
    int i, mntcount;
 
158
    DiskInfo *disk_info;
 
159
 
 
160
    /* let's hope there is no difference between the DiskStatList and
 
161
       the number of mounted file systems */
 
162
    empty_ctnr(DiskStatList);
 
163
 
 
164
    mntcount = getmntinfo(&fs_info, MNT_WAIT);
 
165
 
 
166
    for (i = 0; i < mntcount; i++) {
 
167
        fs = fs_info[i];
 
168
        if (strcmp(fs.f_fstypename, "procfs") && strcmp(fs.f_fstypename, "devfs") && strcmp(fs.f_fstypename, "linprocfs")) {
 
169
            if ( fs.f_blocks != 0 )
 
170
                percent = (((float)fs.f_blocks - (float)fs.f_bfree)*100.0/(float)fs.f_blocks);
 
171
            else
 
172
                percent = 0;
 
173
            if (fs.f_files != 0)
 
174
                fpercent = (((float)fs.f_files - (float)fs.f_ffree)*100.0/(float)fs.f_files);
 
175
            else
 
176
                fpercent = 0;
 
177
            if ((disk_info = (DiskInfo *)malloc(sizeof(DiskInfo))) == NULL)
 
178
                continue;
 
179
            memset(disk_info, 0, sizeof(DiskInfo));
 
180
            strlcpy(disk_info->device, fs.f_mntfromname, sizeof(disk_info->device));
 
181
            if (!strcmp(fs.f_mntonname, "/"))
 
182
                strncpy(disk_info->mntpnt, "/root", 6);
 
183
            else
 
184
                strlcpy(disk_info->mntpnt, fs.f_mntonname, sizeof(disk_info->mntpnt));
 
185
            disk_info->blocks = fs.f_blocks;
 
186
            disk_info->bfree = fs.f_bfree;
 
187
            disk_info->bused = (fs.f_blocks - fs.f_bfree);
 
188
            disk_info->bused_percent = (int)percent;
 
189
            disk_info->bsize = fs.f_bsize;
 
190
            push_ctnr(DiskStatList, disk_info);
 
191
            disk_info->files = fs.f_files;
 
192
            disk_info->ffree = fs.f_ffree;
 
193
            disk_info->fused = fs.f_files - fs.f_ffree;
 
194
            disk_info->fused_percent = (int)fpercent;
 
195
        }
 
196
    }
 
197
 
 
198
    return 0;
 
199
}
 
200
 
 
201
void printDiskStat(const char* cmd)
 
202
{
 
203
    DiskInfo* disk_info;
 
204
 
 
205
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
206
        fprintf(CurrentClient, "%s\t%ld\t%ld\t%ld\t%d\t%ld\t%ld\t%ld\t%d\t%s\n",
 
207
            disk_info->device,
 
208
            BLK2KB(disk_info, blocks),
 
209
            BLK2KB(disk_info, bused),
 
210
            BLK2KB(disk_info, bfree),
 
211
            disk_info->bused_percent,
 
212
            disk_info->files,
 
213
            disk_info->fused,
 
214
            disk_info->ffree,
 
215
            disk_info->fused_percent,
 
216
            MNTPNT_NAME(disk_info));
 
217
    }
 
218
 
 
219
    fprintf(CurrentClient, "\n");
 
220
}
 
221
 
 
222
void printDiskStatInfo(const char* cmd)
 
223
{
 
224
    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");
 
225
}
 
226
 
 
227
void printDiskStatUsed(const char* cmd)
 
228
{
 
229
    DiskInfo* disk_info;
 
230
    char *mntpnt = (char *)getMntPnt(cmd);
 
231
 
 
232
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
233
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
234
            fprintf(CurrentClient, "%ld\n", BLK2KB(disk_info, bused));
 
235
            return;
 
236
        }
 
237
    }
 
238
 
 
239
    fprintf(CurrentClient, "\n");
 
240
}
 
241
 
 
242
void printDiskStatUsedInfo(const char* cmd)
 
243
{
 
244
    DiskInfo* disk_info;
 
245
    char *mntpnt = (char *)getMntPnt(cmd);
 
246
 
 
247
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
248
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
249
            fprintf(CurrentClient, "Used Space (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), BLK2KB(disk_info, blocks));
 
250
            return;
 
251
        }
 
252
    }
 
253
    fprintf(CurrentClient, "Used Space (%s)\t0\t-\tKB\n", mntpnt);
 
254
}
 
255
 
 
256
void printDiskStatFree(const char* cmd)
 
257
{
 
258
    DiskInfo* disk_info;
 
259
    char *mntpnt = (char *)getMntPnt(cmd);
 
260
 
 
261
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
262
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
263
            fprintf(CurrentClient, "%ld\n", BLK2KB(disk_info, bfree));
 
264
            return;
 
265
        }
 
266
    }
 
267
 
 
268
    fprintf(CurrentClient, "\n");
 
269
}
 
270
 
 
271
void printDiskStatFreeInfo(const char* cmd)
 
272
{
 
273
    DiskInfo* disk_info;
 
274
    char *mntpnt = (char *)getMntPnt(cmd);
 
275
 
 
276
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
277
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
278
            fprintf(CurrentClient, "Free Space (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), BLK2KB(disk_info, blocks));
 
279
            return;
 
280
        }
 
281
    }
 
282
    fprintf(CurrentClient, "Free Space (%s)\t0\t-\tKB\n", mntpnt);
 
283
}
 
284
 
 
285
void printDiskStatPercent(const char* cmd)
 
286
{
 
287
    DiskInfo* disk_info;
 
288
    char *mntpnt = (char *)getMntPnt(cmd);
 
289
 
 
290
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
291
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
292
            fprintf(CurrentClient, "%d\n", disk_info->bused_percent);
 
293
            return;
 
294
        }
 
295
    }
 
296
 
 
297
    fprintf(CurrentClient, "\n");
 
298
}
 
299
 
 
300
void printDiskStatPercentInfo(const char* cmd)
 
301
{
 
302
    char *mntpnt = (char *)getMntPnt(cmd);
 
303
 
 
304
    fprintf(CurrentClient, "Used Space (%s)\t0\t100\t%%\n", mntpnt);
 
305
}
 
306
 
 
307
void printDiskStatIUsed(const char* cmd)
 
308
{
 
309
    DiskInfo* disk_info;
 
310
    char *mntpnt = (char *)getMntPnt(cmd);
 
311
 
 
312
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
313
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
314
            fprintf(CurrentClient, "%ld\n", disk_info->fused);
 
315
            return;
 
316
        }
 
317
    }
 
318
 
 
319
    fprintf(CurrentClient, "\n");
 
320
}
 
321
 
 
322
void printDiskStatIUsedInfo(const char* cmd)
 
323
{
 
324
    DiskInfo* disk_info;
 
325
    char *mntpnt = (char *)getMntPnt(cmd);
 
326
 
 
327
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
328
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
329
            fprintf(CurrentClient, "Used Inodes (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), disk_info->files);
 
330
            return;
 
331
        }
 
332
    }
 
333
    fprintf(CurrentClient, "Used Inodes(%s)\t0\t-\tKB\n", mntpnt);
 
334
}
 
335
 
 
336
void printDiskStatIFree(const char* cmd)
 
337
{
 
338
    DiskInfo* disk_info;
 
339
    char *mntpnt = (char *)getMntPnt(cmd);
 
340
 
 
341
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
342
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
343
            fprintf(CurrentClient, "%ld\n", disk_info->ffree);
 
344
            return;
 
345
        }
 
346
    }
 
347
 
 
348
    fprintf(CurrentClient, "\n");
 
349
}
 
350
 
 
351
void printDiskStatIFreeInfo(const char* cmd)
 
352
{
 
353
    DiskInfo* disk_info;
 
354
    char *mntpnt = (char *)getMntPnt(cmd);
 
355
 
 
356
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
357
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
358
            fprintf(CurrentClient, "Free Inodes (%s)\t0\t%ld\tKB\n", MNTPNT_NAME(disk_info), disk_info->files);
 
359
            return;
 
360
        }
 
361
    }
 
362
    fprintf(CurrentClient, "Free Inodes (%s)\t0\t-\tKB\n", mntpnt);
 
363
}
 
364
 
 
365
void printDiskStatIPercent(const char* cmd)
 
366
{
 
367
    DiskInfo* disk_info;
 
368
    char *mntpnt = (char *)getMntPnt(cmd);
 
369
 
 
370
    for (disk_info = first_ctnr(DiskStatList); disk_info; disk_info = next_ctnr(DiskStatList)) {
 
371
        if (!strcmp(mntpnt, disk_info->mntpnt)) {
 
372
            fprintf(CurrentClient, "%d\n", disk_info->fused_percent);
 
373
            return;
 
374
        }
 
375
    }
 
376
 
 
377
    fprintf(CurrentClient, "\n");
 
378
}
 
379
 
 
380
void printDiskStatIPercentInfo(const char* cmd)
 
381
{
 
382
    char *mntpnt = (char *)getMntPnt(cmd);
 
383
 
 
384
    fprintf(CurrentClient, "Used Inodes (%s)\t0\t100\t%%\n", mntpnt);
 
385
}
 
386