← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/net-snmp/gutsy-security

« back to all changes in this revision

Viewing changes to agent/mibgroup/ucd-snmp/vmstat_bsdi4.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2004-09-13 12:06:21 UTC
  • Revision ID: james.westby@ubuntu.com-20040913120621-g952ntonlleihcvm
Tags: upstream-5.1.1
Import upstream version 5.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
agent/mibgroup/ucd-snmp/vmstat_bsdi4.c
 
1
/*
 
2
 * vmstat_bsdi4.c
 
3
 */
 
4
 
 
5
#include <net-snmp/net-snmp-config.h>
 
6
 
 
7
/*
 
8
 * Ripped from /usr/scr/usr.bin/vmstat/vmstat.c (covering all bases) 
 
9
 */
 
10
#include <sys/param.h>
 
11
#include <sys/time.h>
 
12
#include <sys/proc.h>
 
13
#include <sys/dkstat.h>
 
14
#include <sys/buf.h>
 
15
#include <sys/uio.h>
 
16
#include <sys/namei.h>
 
17
#include <sys/malloc.h>
 
18
#include <sys/signal.h>
 
19
#include <sys/fcntl.h>
 
20
#include <sys/ioctl.h>
 
21
#include <sys/sysctl.h>
 
22
#include <sys/vmmeter.h>
 
23
 
 
24
#include <vm/vm_param.h>
 
25
#include <vm/vm_extern.h>
 
26
 
 
27
#include <time.h>
 
28
#include <nlist.h>
 
29
#include <kvm.h>
 
30
#include <errno.h>
 
31
#include <unistd.h>
 
32
#include <stdio.h>
 
33
#include <ctype.h>
 
34
#include <stdlib.h>
 
35
#include <string.h>
 
36
#include <paths.h>
 
37
#include <limits.h>
 
38
 
 
39
 
 
40
#include <net-snmp/net-snmp-includes.h>
 
41
#include <net-snmp/agent/net-snmp-agent-includes.h>
 
42
#include <net-snmp/agent/auto_nlist.h>
 
43
 
 
44
#include "util_funcs.h"
 
45
#include "vmstat.h"
 
46
 
 
47
/*
 
48
 * CPU percentage 
 
49
 */
 
50
#define CPU_PRC         100
 
51
#define BOOTTIME_SYMBOL "boottime"
 
52
 
 
53
FindVarMethod var_extensible_vmstat;
 
54
 
 
55
void
 
56
init_vmstat_bsdi4(void)
 
57
{
 
58
 
 
59
    struct variable2 extensible_vmstat_variables[] = {
 
60
        {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
 
61
         {MIBINDEX}},
 
62
        {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_vmstat, 1,
 
63
         {ERRORNAME}},
 
64
        {SWAPIN, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {SWAPIN}},
 
65
        {SWAPOUT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {SWAPOUT}},
 
66
        {IOSENT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {IOSENT}},
 
67
        {IORECEIVE, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
 
68
         {IORECEIVE}},
 
69
        {SYSINTERRUPTS, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
 
70
         {SYSINTERRUPTS}},
 
71
        {SYSCONTEXT, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
 
72
         {SYSCONTEXT}},
 
73
        {CPUUSER, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {CPUUSER}},
 
74
        {CPUSYSTEM, ASN_INTEGER, RONLY, var_extensible_vmstat, 1,
 
75
         {CPUSYSTEM}},
 
76
        {CPUIDLE, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {CPUIDLE}},
 
77
        {CPURAWUSER, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
78
         {CPURAWUSER}},
 
79
        {CPURAWNICE, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
80
         {CPURAWNICE}},
 
81
        {CPURAWSYSTEM, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
82
         {CPURAWSYSTEM}},
 
83
        {CPURAWIDLE, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
84
         {CPURAWIDLE}},
 
85
        {CPURAWKERNEL, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
86
         {CPURAWKERNEL}},
 
87
        {CPURAWINTR, ASN_COUNTER, RONLY, var_extensible_vmstat, 1,
 
88
         {CPURAWINTR}},
 
89
        /*
 
90
         * Future use: 
 
91
         */
 
92
        /*
 
93
         * {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_vmstat, 1, {ERRORFLAG }},
 
94
         * {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_vmstat, 1, {ERRORMSG }}
 
95
         */
 
96
    };
 
97
 
 
98
    /*
 
99
     * Define the OID pointer to the top of the mib tree that we're
 
100
     * registering underneath 
 
101
     */
 
102
    oid             vmstat_variables_oid[] = { UCDAVIS_MIB, 11 };
 
103
 
 
104
    /*
 
105
     * register ourselves with the agent to handle our mib tree 
 
106
     */
 
107
    REGISTER_MIB("ucd-snmp/vmstat", extensible_vmstat_variables, variable2,
 
108
                 vmstat_variables_oid);
 
109
 
 
110
}
 
111
 
 
112
 
 
113
long
 
114
getuptime(void)
 
115
{
 
116
    static time_t   now, boottime;
 
117
    time_t          uptime;
 
118
 
 
119
    if (boottime == 0)
 
120
        auto_nlist(BOOTTIME_SYMBOL, (char *) &boottime, sizeof(boottime));
 
121
 
 
122
    time(&now);
 
123
    uptime = now - boottime;
 
124
 
 
125
    return (uptime);
 
126
}
 
127
 
 
128
unsigned char  *
 
129
var_extensible_vmstat(struct variable *vp,
 
130
                      oid * name,
 
131
                      size_t * length,
 
132
                      int exact,
 
133
                      size_t * var_len, WriteMethod ** write_method)
 
134
{
 
135
 
 
136
    int             loop;
 
137
 
 
138
    time_t          time_new = getuptime();
 
139
    static time_t   time_old;
 
140
    static time_t   time_diff;
 
141
 
 
142
    static long     cpu_old[CPUSTATES];
 
143
    static long     cpu_new[CPUSTATES];
 
144
    static long     cpu_diff[CPUSTATES];
 
145
    static long     cpu_total;
 
146
    long            cpu_sum;
 
147
    double          cpu_prc;
 
148
 
 
149
    static struct vmmeter mem_old, mem_new;
 
150
    int             mem_mib[] = { CTL_VM, VM_CNT };
 
151
    int             mem_size = sizeof(struct vmmeter);
 
152
    int             cpu_mib[] = { CTL_KERN, KERN_CPUSTATS };
 
153
    int             cpu_size = sizeof(struct cpustats);
 
154
 
 
155
    static long     long_ret;
 
156
    static char     errmsg[300];
 
157
 
 
158
    long_ret = 0;               /* set to 0 as default */
 
159
 
 
160
    if (header_generic(vp, name, length, exact, var_len, write_method))
 
161
        return (NULL);
 
162
 
 
163
    /*
 
164
     * Update structures (only if time has passed) 
 
165
     */
 
166
    if (time_new != time_old) {
 
167
        time_diff = time_new - time_old;
 
168
        time_old = time_new;
 
169
 
 
170
        /*
 
171
         * CPU usage 
 
172
         */
 
173
        sysctl(cpu_mib, 2, &cpu_new, &cpu_size, NULL, 0);
 
174
 
 
175
        cpu_total = 0;
 
176
 
 
177
        for (loop = 0; loop < CPUSTATES; loop++) {
 
178
            cpu_diff[loop] = cpu_new[loop] - cpu_old[loop];
 
179
            cpu_old[loop] = cpu_new[loop];
 
180
            cpu_total += cpu_diff[loop];
 
181
        }
 
182
 
 
183
        if (cpu_total == 0)
 
184
            cpu_total = 1;
 
185
 
 
186
        /*
 
187
         * Memory info 
 
188
         */
 
189
        mem_old = mem_new;
 
190
        sysctl(mem_mib, 2, &mem_new, &mem_size, NULL, 0);
 
191
    }
 
192
 
 
193
    /*
 
194
     * Rate macro 
 
195
     */
 
196
#define rate(x) (((x)+ time_diff/2) / time_diff)
 
197
 
 
198
    /*
 
199
     * Page-to-kb macro 
 
200
     */
 
201
#define ptok(p) ((p) * (mem_new.v_page_size >> 10))
 
202
 
 
203
    switch (vp->magic) {
 
204
    case MIBINDEX:
 
205
        long_ret = 1;
 
206
        return ((u_char *) (&long_ret));
 
207
    case ERRORNAME:            /* dummy name */
 
208
        sprintf(errmsg, "systemStats");
 
209
        *var_len = strlen(errmsg);
 
210
        return ((u_char *) (errmsg));
 
211
    case SWAPIN:
 
212
        long_ret = ptok(mem_new.v_swpin - mem_old.v_swpin);
 
213
        long_ret = rate(long_ret);
 
214
        return ((u_char *) (&long_ret));
 
215
    case SWAPOUT:
 
216
        long_ret = ptok(mem_new.v_swpout - mem_old.v_swpout);
 
217
        long_ret = rate(long_ret);
 
218
        return ((u_char *) (&long_ret));
 
219
    case IOSENT:
 
220
#if NO_DUMMY_VALUES
 
221
        return NULL;
 
222
#endif
 
223
        long_ret = -1;
 
224
        return ((u_char *) (&long_ret));
 
225
    case IORECEIVE:
 
226
#if NO_DUMMY_VALUES
 
227
        return NULL;
 
228
#endif
 
229
        long_ret = -1;
 
230
        return ((u_char *) (&long_ret));
 
231
    case SYSINTERRUPTS:
 
232
        long_ret = rate(mem_new.v_intr - mem_old.v_intr);
 
233
        return ((u_char *) (&long_ret));
 
234
    case SYSCONTEXT:
 
235
        long_ret = rate(mem_new.v_swtch - mem_old.v_swtch);
 
236
        return ((u_char *) (&long_ret));
 
237
    case CPUUSER:
 
238
        cpu_sum = cpu_diff[CP_USER] + cpu_diff[CP_NICE];
 
239
        cpu_prc = (float) cpu_sum / (float) cpu_total;
 
240
        long_ret = cpu_prc * CPU_PRC;
 
241
        return ((u_char *) (&long_ret));
 
242
    case CPUSYSTEM:
 
243
        cpu_sum = cpu_diff[CP_SYS] + cpu_diff[CP_INTR];
 
244
        cpu_prc = (float) cpu_sum / (float) cpu_total;
 
245
        long_ret = cpu_prc * CPU_PRC;
 
246
        return ((u_char *) (&long_ret));
 
247
    case CPUIDLE:
 
248
        cpu_sum = cpu_diff[CP_IDLE];
 
249
        cpu_prc = (float) cpu_sum / (float) cpu_total;
 
250
        long_ret = cpu_prc * CPU_PRC;
 
251
        return ((u_char *) (&long_ret));
 
252
    case CPURAWUSER:
 
253
        long_ret = cpu_new[CP_USER];
 
254
        return ((u_char *) (&long_ret));
 
255
    case CPURAWNICE:
 
256
        long_ret = cpu_new[CP_NICE];
 
257
        return ((u_char *) (&long_ret));
 
258
    case CPURAWSYSTEM:
 
259
        long_ret = cpu_new[CP_SYS] + cpu_new[CP_INTR];
 
260
        return ((u_char *) (&long_ret));
 
261
    case CPURAWIDLE:
 
262
        long_ret = cpu_new[CP_IDLE];
 
263
        return ((u_char *) (&long_ret));
 
264
    case CPURAWKERNEL:
 
265
        long_ret = cpu_new[CP_SYS];
 
266
        return ((u_char *) (&long_ret));
 
267
    case CPURAWINTR:
 
268
        long_ret = cpu_new[CP_INTR];
 
269
        return ((u_char *) (&long_ret));
 
270
        /*
 
271
         * reserved for future use 
 
272
         */
 
273
        /*
 
274
         * case ERRORFLAG:
 
275
         * return((u_char *) (&long_ret));
 
276
         * case ERRORMSG:
 
277
         * return((u_char *) (&long_ret));
 
278
         */
 
279
    }
 
280
    return NULL;
 
281
}