Debian Codegraph @

agent/mibgroup/ucd-snmp/memory_solaris2.c

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