← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ksysguard/ksysguardd/OpenBSD/memory.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/OpenBSD/memory.c
 
1
/*
 
2
    KSysGuard, the KDE System Guard
 
3
 
 
4
    Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
 
5
    Copyright (c) 1999-2000 Hans Petter Bieker <bieker@kde.org>
 
6
 
 
7
    This program is free software; you can redistribute it and/or modify
 
8
    it under the terms of the GNU General Public License as published by
 
9
    the Free Software Foundation; either version 2 of the License, or
 
10
    (at your option) any later version.
 
11
 
 
12
    This program is distributed in the hope that it will be useful,
 
13
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
    GNU General Public License for more details.
 
16
 
 
17
    You should have received a copy of the GNU General Public License
 
18
    along with this program; if not, write to the Free Software
 
19
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
20
 
 
21
*/
 
22
 
 
23
#include <sys/param.h>
 
24
#include <sys/sysctl.h>
 
25
#include <sys/dkstat.h>
 
26
#include <sys/swap.h>
 
27
 
 
28
#include <limits.h>
 
29
#include <stdio.h>
 
30
#include <stdlib.h>
 
31
#include <string.h>
 
32
#include <unistd.h>
 
33
 
 
34
#include "Command.h"
 
35
#include "memory.h"
 
36
#include "ksysguardd.h"
 
37
 
 
38
static size_t Total = 0;
 
39
static size_t MFree = 0;
 
40
static size_t Used = 0;
 
41
static size_t Application = 0;
 
42
static size_t Active = 0;
 
43
static size_t InActive = 0;
 
44
static size_t STotal = 0;
 
45
static size_t SFree = 0;
 
46
static size_t SUsed = 0;
 
47
static int pageshift = 0;
 
48
 
 
49
/* define pagetok in terms of pageshift */
 
50
#define pagetok(size) ((size) << pageshift)
 
51
 
 
52
void swapmode(int *used, int *total);
 
53
 
 
54
void
 
55
initMemory(struct SensorModul* sm)
 
56
{
 
57
        int pagesize;
 
58
        static int physmem_mib[] = { CTL_HW, HW_PHYSMEM };
 
59
        size_t size;
 
60
        /* get the page size with "getpagesize" and calculate pageshift from
 
61
        * it */
 
62
        pagesize = getpagesize();
 
63
        pageshift = 0;
 
64
        while (pagesize > 1) {
 
65
                pageshift++;
 
66
                pagesize >>= 1;
 
67
        }
 
68
        size = sizeof(Total);
 
69
        sysctl(physmem_mib, 2, &Total, &size, NULL, 0);
 
70
        Total /= 1024;
 
71
        swapmode(&SUsed, &STotal);
 
72
 
 
73
  registerMonitor("mem/physical/free", "integer", printMFree, printMFreeInfo, sm);
 
74
        registerMonitor("mem/physical/active", "integer", printActive, printActiveInfo, sm);
 
75
        registerMonitor("mem/physical/inactive", "integer", printInActive, printInActiveInfo, sm);
 
76
        registerMonitor("mem/physical/used", "integer", printUsed, printUsedInfo, sm);
 
77
        registerMonitor("mem/physical/application", "integer", printApplication, printApplicationInfo, sm);
 
78
        registerMonitor("mem/swap/free", "integer", printSwapFree, printSwapFreeInfo, sm);
 
79
        registerMonitor("mem/swap/used", "integer", printSwapUsed, printSwapUsedInfo, sm);
 
80
}
 
81
 
 
82
void
 
83
exitMemory(void)
 
84
{
 
85
}
 
86
 
 
87
int
 
88
updateMemory(void)
 
89
{
 
90
        static int vmtotal_mib[] = {CTL_VM, VM_METER};
 
91
        size_t size;
 
92
        struct vmtotal vmtotal;
 
93
        size = sizeof(vmtotal);
 
94
 
 
95
        if (sysctl(vmtotal_mib, 2, &vmtotal, &size, NULL, 0) < 0)
 
96
                return -1;
 
97
 
 
98
        MFree = pagetok(vmtotal.t_free);
 
99
        MFree /= 1024;
 
100
        Active = pagetok(vmtotal.t_arm);
 
101
        Active /= 1024;
 
102
        InActive = pagetok(vmtotal.t_rm);
 
103
        InActive /= 1024;
 
104
        InActive -= Active;
 
105
 
 
106
        Used = Total - MFree;
 
107
        Application = Used;
 
108
 
 
109
        swapmode(&SUsed, &STotal);
 
110
        SFree = STotal - SUsed;
 
111
        return 0;
 
112
}
 
113
 
 
114
void
 
115
printMFree(const char* cmd)
 
116
{
 
117
        fprintf(CurrentClient, "%d\n", MFree);
 
118
}
 
119
 
 
120
void
 
121
printMFreeInfo(const char* cmd)
 
122
{
 
123
        fprintf(CurrentClient, "Free Memory\t0\t%d\tKB\n", Total);
 
124
}
 
125
 
 
126
void
 
127
printUsed(const char* cmd)
 
128
{
 
129
        fprintf(CurrentClient, "%d\n", Used);
 
130
}
 
131
 
 
132
void
 
133
printUsedInfo(const char* cmd)
 
134
{
 
135
        fprintf(CurrentClient, "Used Memory\t0\t%d\tKB\n", Total);
 
136
}
 
137
 
 
138
void
 
139
printApplication(const char* cmd)
 
140
{
 
141
        fprintf(CurrentClient, "%d\n", Application);
 
142
}
 
143
 
 
144
void
 
145
printApplicationInfo(const char* cmd)
 
146
{
 
147
        fprintf(CurrentClient, "Application Memory\t0\t%ld\tKB\n", Total);
 
148
}
 
149
 
 
150
void
 
151
printActive(const char* cmd)
 
152
{
 
153
        fprintf(CurrentClient, "%d\n", Active);
 
154
}
 
155
 
 
156
void
 
157
printActiveInfo(const char* cmd)
 
158
{
 
159
        fprintf(CurrentClient, "Active Memory\t0\t%d\tKB\n", Total);
 
160
}
 
161
 
 
162
void
 
163
printInActive(const char* cmd)
 
164
{
 
165
        fprintf(CurrentClient, "%d\n", InActive);
 
166
}
 
167
 
 
168
void
 
169
printInActiveInfo(const char* cmd)
 
170
{
 
171
        fprintf(CurrentClient, "InActive Memory\t0\t%d\tKB\n", Total);
 
172
}
 
173
 
 
174
void
 
175
printSwapUsed(const char* cmd)
 
176
{
 
177
        fprintf(CurrentClient, "%d\n", SUsed);
 
178
}
 
179
 
 
180
void
 
181
printSwapUsedInfo(const char* cmd)
 
182
{
 
183
        fprintf(CurrentClient, "Used Swap Memory\t0\t%d\tKB\n", STotal);
 
184
}
 
185
 
 
186
void
 
187
printSwapFree(const char* cmd)
 
188
{
 
189
        fprintf(CurrentClient, "%d\n", SFree);
 
190
}
 
191
 
 
192
void
 
193
printSwapFreeInfo(const char* cmd)
 
194
{
 
195
        fprintf(CurrentClient, "Free Swap Memory\t0\t%d\tKB\n", STotal);
 
196
}
 
197
 
 
198
/*
 
199
This function swapmode was originally written by Tobias
 
200
Weingartner <weingart@openbsd.org>
 
201
 
 
202
Taken from OpenBSD top command
 
203
*/
 
204
void
 
205
swapmode (int *used, int *total)
 
206
{
 
207
        int     nswap, rnswap, i;
 
208
        struct swapent *swdev;
 
209
 
 
210
        *total = *used = 0;
 
211
 
 
212
        /* Number of swap devices */
 
213
        nswap = swapctl(SWAP_NSWAP, 0, 0);
 
214
        if (nswap == 0)
 
215
                return;
 
216
 
 
217
        swdev = (struct swapent *) malloc(nswap * sizeof(*swdev));
 
218
        if (swdev == NULL)
 
219
                return;
 
220
 
 
221
        rnswap = swapctl(SWAP_STATS, swdev, nswap);
 
222
        if (rnswap == -1) {
 
223
    free(swdev);
 
224
                return;
 
225
  }
 
226
 
 
227
        /* if rnswap != nswap, then what? */
 
228
 
 
229
        /* Total things up */
 
230
        for (i = 0; i < nswap; i++) {
 
231
                if (swdev[i].se_flags & SWF_ENABLE) {
 
232
                        *used += (swdev[i].se_inuse / (1024 / DEV_BSIZE));
 
233
                        *total += (swdev[i].se_nblks / (1024 / DEV_BSIZE));
 
234
                }
 
235
        }
 
236
 
 
237
        free(swdev);
 
238
}