← Back to branch summary

~ubuntu-branches/ubuntu/trusty/net-snmp/trusty

« back to all changes in this revision

Viewing changes to agent/mibgroup/ucd-snmp/memory_solaris2.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/memory_solaris2.c
 
1
#include <net-snmp/net-snmp-config.h>   /* local SNMP configuration details */
 
2
#if HAVE_STRING_H
 
3
#include <string.h>
 
4
#endif
 
5
#if HAVE_STDLIB_H
 
6
#include <stdlib.h>
 
7
#endif
 
8
 
 
9
#include <sys/types.h>
 
10
 
 
11
#if HAVE_DMALLOC_H
 
12
#include <dmalloc.h>
 
13
#endif
 
14
 
 
15
#include <net-snmp/net-snmp-includes.h>
 
16
#include <net-snmp/agent/net-snmp-agent-includes.h>
 
17
#include <net-snmp/agent/auto_nlist.h>
 
18
 
 
19
#include "util_funcs.h"         /* utility function declarations */
 
20
#include "memory.h"             /* the module-specific header */
 
21
#include "memory_solaris2.h"    /* the module-specific header */
 
22
 
 
23
#include <kstat.h>
 
24
#include <sys/stat.h>
 
25
#include <sys/swap.h>
 
26
#include <unistd.h>
 
27
 
 
28
#define MAXSTRSIZE      80
 
29
 
 
30
int             minimumswap;
 
31
static char     errmsg[1024];
 
32
/****************************
 
33
 * Kstat specific variables *
 
34
 ****************************/
 
35
extern kstat_ctl_t *kstat_fd;   /* defined in kernel_sunos5.c */
 
36
kstat_t        *ksp1, *ksp2;
 
37
kstat_named_t  *kn, *kn2;
 
38
 
 
39
static FindVarMethod var_extensible_mem;
 
40
static long     getFreeSwap(void);
 
41
static long     getTotalFree(void);
 
42
static long     getTotalSwap(void);
 
43
 
 
44
void
 
45
init_memory_solaris2(void)
 
46
{
 
47
 
 
48
    struct variable2 extensible_mem_variables[] = {
 
49
        {MIBINDEX, ASN_INTEGER, RONLY, var_extensible_mem, 1, {MIBINDEX}},
 
50
        {ERRORNAME, ASN_OCTET_STR, RONLY, var_extensible_mem, 1,
 
51
         {ERRORNAME}},
 
52
        {MEMTOTALSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
53
         {MEMTOTALSWAP}},
 
54
        {MEMAVAILSWAP, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
55
         {MEMAVAILSWAP}},
 
56
        {MEMTOTALREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
57
         {MEMTOTALREAL}},
 
58
        {MEMAVAILREAL, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
59
         {MEMAVAILREAL}},
 
60
        {MEMTOTALSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
61
         {MEMTOTALSWAPTXT}},
 
62
        {MEMUSEDSWAPTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
63
         {MEMUSEDSWAPTXT}},
 
64
        {MEMTOTALREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
65
         {MEMTOTALREALTXT}},
 
66
        {MEMUSEDREALTXT, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
67
         {MEMUSEDREALTXT}},
 
68
        {MEMTOTALFREE, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
69
         {MEMTOTALFREE}},
 
70
        {MEMSWAPMINIMUM, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
71
         {MEMSWAPMINIMUM}},
 
72
        {MEMSHARED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
73
         {MEMSHARED}},
 
74
        {MEMBUFFER, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
75
         {MEMBUFFER}},
 
76
        {MEMCACHED, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
77
         {MEMCACHED}},
 
78
        {ERRORFLAG, ASN_INTEGER, RONLY, var_extensible_mem, 1,
 
79
         {ERRORFLAG}},
 
80
        {ERRORMSG, ASN_OCTET_STR, RONLY, var_extensible_mem, 1, {ERRORMSG}}
 
81
    };
 
82
 
 
83
    /*
 
84
     * Define the OID pointer to the top of the mib tree that we're
 
85
     * registering underneath 
 
86
     */
 
87
    oid             mem_variables_oid[] = { UCDAVIS_MIB, MEMMIBNUM };
 
88
 
 
89
    /*
 
90
     * register ourselves with the agent to handle our mib tree 
 
91
     */
 
92
    REGISTER_MIB("ucd-snmp/memory", extensible_mem_variables, variable2,
 
93
                 mem_variables_oid);
 
94
 
 
95
    snmpd_register_config_handler("swap", memory_parse_config,
 
96
                                  memory_free_config, "min-avail");
 
97
 
 
98
    if (kstat_fd == 0) {
 
99
        kstat_fd = kstat_open();
 
100
        if (kstat_fd == 0) {
 
101
            snmp_log_perror("kstat_open");
 
102
        }
 
103
    }
 
104
}
 
105
 
 
106
static u_char  *
 
107
var_extensible_mem(struct variable *vp,
 
108
                   oid * name,
 
109
                   size_t * length,
 
110
                   int exact,
 
111
                   size_t * var_len, WriteMethod ** write_method)
 
112
{
 
113
    static long     long_ret;
 
114
 
 
115
    /*
 
116
     * Initialize the return value to 0 
 
117
     */
 
118
    long_ret = 0;
 
119
 
 
120
    if (header_generic(vp, name, length, exact, var_len, write_method))
 
121
        return (NULL);
 
122
 
 
123
    switch (vp->magic) {
 
124
    case MIBINDEX:
 
125
        long_ret = 0;
 
126
        return ((u_char *) (&long_ret));
 
127
    case ERRORNAME:            /* dummy name */
 
128
        sprintf(errmsg, "swap");
 
129
        *var_len = strlen(errmsg);
 
130
        return ((u_char *) (errmsg));
 
131
    case MEMTOTALSWAP:
 
132
        long_ret = getTotalSwap() * (getpagesize() / 1024);
 
133
        return ((u_char *) (&long_ret));
 
134
    case MEMAVAILSWAP:
 
135
        long_ret = getFreeSwap() * (getpagesize() / 1024);
 
136
        return ((u_char *) (&long_ret));
 
137
    case MEMSWAPMINIMUM:
 
138
        long_ret = minimumswap;
 
139
        return ((u_char *) (&long_ret));
 
140
    case MEMTOTALREAL:
 
141
#ifdef _SC_PHYS_PAGES
 
142
        long_ret = sysconf(_SC_PHYS_PAGES) * (getpagesize()/1024);
 
143
#else
 
144
        ksp1 = kstat_lookup(kstat_fd, "unix", 0, "system_pages");
 
145
        kstat_read(kstat_fd, ksp1, 0);
 
146
        kn = kstat_data_lookup(ksp1, "physmem");
 
147
 
 
148
        long_ret = kn->value.ul * (getpagesize() / 1024);
 
149
#endif
 
150
        return ((u_char *) (&long_ret));
 
151
    case MEMAVAILREAL:
 
152
#ifdef _SC_AVPHYS_PAGES
 
153
        long_ret = sysconf(_SC_AVPHYS_PAGES) * (getpagesize()/1024);
 
154
#else
 
155
        long_ret =
 
156
            (getTotalFree() - getFreeSwap()) * (getpagesize() / 1024);
 
157
#endif
 
158
        return ((u_char *) (&long_ret));
 
159
    case MEMTOTALFREE:
 
160
        long_ret = getTotalFree() * (getpagesize() / 1024);
 
161
        return ((u_char *) (&long_ret));
 
162
 
 
163
    case ERRORFLAG:
 
164
        long_ret = getTotalFree() * (getpagesize() / 1024);
 
165
        long_ret = (long_ret > minimumswap) ? 0 : 1;
 
166
        return ((u_char *) (&long_ret));
 
167
 
 
168
    case ERRORMSG:
 
169
        long_ret = getTotalFree() * (getpagesize() / 1024);
 
170
        if ((long_ret > minimumswap) ? 0 : 1)
 
171
            sprintf(errmsg, "Running out of swap space (%ld)", long_ret);
 
172
        else
 
173
            errmsg[0] = 0;
 
174
        *var_len = strlen(errmsg);
 
175
        return ((u_char *) (errmsg));
 
176
 
 
177
    }
 
178
 
 
179
    return (NULL);
 
180
}
 
181
 
 
182
#define DEFAULTMINIMUMSWAP 16000        /* kilobytes */
 
183
 
 
184
void
 
185
memory_parse_config(const char *token, char *cptr)
 
186
{
 
187
    minimumswap = atoi(cptr);
 
188
}
 
189
 
 
190
void
 
191
memory_free_config(void)
 
192
{
 
193
    minimumswap = DEFAULTMINIMUMSWAP;
 
194
}
 
195
 
 
196
long
 
197
getTotalSwap(void)
 
198
{
 
199
    long            total_mem;
 
200
 
 
201
    size_t          num;
 
202
    int             i, n;
 
203
    swaptbl_t      *s;
 
204
    char           *strtab;
 
205
 
 
206
    total_mem = 0;
 
207
 
 
208
    num = swapctl(SC_GETNSWP, 0);
 
209
    s = malloc(num * sizeof(swapent_t) + sizeof(struct swaptable));
 
210
    if (s) {
 
211
        strtab = (char *) malloc((num + 1) * MAXSTRSIZE);
 
212
        if (strtab) {
 
213
            for (i = 0; i < (num + 1); i++) {
 
214
                s->swt_ent[i].ste_path = strtab + (i * MAXSTRSIZE);
 
215
            }
 
216
            s->swt_n = num + 1;
 
217
            n = swapctl(SC_LIST, s);
 
218
 
 
219
            for (i = 0; i < n; i++)
 
220
                total_mem += s->swt_ent[i].ste_pages;
 
221
 
 
222
            free(strtab);
 
223
        }
 
224
        free(s);
 
225
    }
 
226
 
 
227
    return (total_mem);
 
228
}
 
229
 
 
230
/*
 
231
 * returns -1 if malloc fails.
 
232
 */
 
233
static long
 
234
getFreeSwap(void)
 
235
{
 
236
    long            free_mem = -1;
 
237
 
 
238
    size_t          num;
 
239
    int             i, n;
 
240
    swaptbl_t      *s;
 
241
    char           *strtab;
 
242
 
 
243
    num = swapctl(SC_GETNSWP, 0);
 
244
    s = malloc(num * sizeof(swapent_t) + sizeof(struct swaptable));
 
245
    if (s) {
 
246
        strtab = (char *) malloc((num + 1) * MAXSTRSIZE);
 
247
        if (strtab) {
 
248
            free_mem = 0;
 
249
            for (i = 0; i < (num + 1); i++) {
 
250
                s->swt_ent[i].ste_path = strtab + (i * MAXSTRSIZE);
 
251
            }
 
252
            s->swt_n = num + 1;
 
253
            n = swapctl(SC_LIST, s);
 
254
 
 
255
            for (i = 0; i < n; i++)
 
256
                free_mem += s->swt_ent[i].ste_free;
 
257
 
 
258
            free(strtab);
 
259
        }
 
260
        free(s);
 
261
    }
 
262
 
 
263
    return (free_mem);
 
264
}
 
265
 
 
266
static long
 
267
getTotalFree(void)
 
268
{
 
269
    unsigned long   free_mem, allocated, reserved, available, used_size;
 
270
    struct anoninfo ai;
 
271
 
 
272
    if (-1 == swapctl(SC_AINFO, &ai)) {
 
273
        snmp_log_perror("swapctl(SC_AINFO)");
 
274
        return 0;
 
275
    }
 
276
    allocated = ai.ani_max - ai.ani_free;
 
277
    reserved = (ai.ani_resv - allocated);
 
278
    available = (ai.ani_max - ai.ani_resv);     /* K-byte */
 
279
    free_mem = used_size = reserved + allocated;
 
280
    free_mem = available;
 
281
    return (free_mem);
 
282
}