Debian Codegraph @

agent/mibgroup/hardware/memory/memory_freebsd.c

raw
1 #include <net-snmp/net-snmp-config.h>
2 #include <net-snmp/net-snmp-includes.h>
3 #include <net-snmp/agent/net-snmp-agent-includes.h>
4 #include <net-snmp/agent/auto_nlist.h>
5 #include <net-snmp/agent/hardware/memory.h>
6 #include "../../../kernel.h"
7
8 #include <unistd.h>
9 #include <sys/param.h>
10 #include <sys/fcntl.h>
11 #include <sys/sysctl.h>
12 #include <sys/vmmeter.h>
13 #include <kvm.h>
14
15 #ifdef HAVE_SYS_VMPARAM_H
16 #include <sys/vmparam.h>
17 #else
18 #include <vm/vm_param.h>
19 #endif
20
21 #define SUM_SYMBOL "cnt"
22 #define BUFSPACE_SYMBOL "bufspace"
23
24 quad_t swapTotal;
25 quad_t swapUsed;
26 quad_t swapFree;
27
28 static int swapmode(long);
29
30
31 /*
32 * Load the latest memory usage statistics
33 */
34 int netsnmp_mem_arch_load( netsnmp_cache *cache, void *magic ) {
35
36 netsnmp_memory_info *mem;
37 long pagesize;
38 int nswap;
39
40 #if !defined(VM_TOTAL)
41 unsigned int free_mem;
42 size_t free_size = sizeof(free_mem);
43 unsigned int mem_pages;
44 #else
45 struct vmtotal total;
46 size_t total_size = sizeof(total);
47 int total_mib[] = { CTL_VM, VM_TOTAL };
48 #endif
49
50 u_long phys_mem;
51 u_long user_mem;
52 unsigned int cache_count;
53 unsigned int cache_max;
54 unsigned int bufspace;
55 unsigned int maxbufspace;
56 unsigned int inact_count;
57 size_t mem_size = sizeof(phys_mem);
58 size_t cache_size = sizeof(cache_count);
59 size_t buf_size = sizeof(bufspace);
60 size_t inact_size = sizeof(inact_count);
61 int phys_mem_mib[] = { CTL_HW, HW_PHYSMEM };
62 int user_mem_mib[] = { CTL_HW, HW_USERMEM };
63
64 /*
65 * Retrieve the memory information from the underlying O/S...
66 */
67 #if !defined(VM_TOTAL)
68 sysctlbyname("vm.stats.vm.v_free_count", &free_mem, &free_size, NULL, 0);
69 sysctlbyname("vm.stats.vm.v_page_count", &mem_pages, &free_size, NULL, 0);
70 #else
71 sysctl(total_mib, 2, &total, &total_size, NULL, 0);
72 #endif
73 sysctl(phys_mem_mib, 2, &phys_mem, &mem_size, NULL, 0);
74 sysctl(user_mem_mib, 2, &user_mem, &mem_size, NULL, 0);
75 sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &cache_size, NULL, 0);
76 sysctlbyname("vm.stats.vm.v_cache_max", &cache_max, &cache_size, NULL, 0);
77 sysctlbyname("vm.stats.vm.v_inactive_count", &inact_count, &inact_size, NULL, 0);
78 sysctlbyname("vfs.bufspace", &bufspace, &buf_size, NULL, 0);
79 sysctlbyname("vfs.maxbufspace", &maxbufspace, &buf_size, NULL, 0);
80 #ifndef freebsd4
81 pagesize = 1024;
82 #else
83 pagesize = getpagesize();
84 #endif
85
86 /*
87 * ... and save this in a standard form.
88 */
89 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_PHYSMEM, 1 );
90 if (!mem) {
91 snmp_log_perror("No Physical Memory info entry");
92 } else {
93 if (!mem->descr)
94 mem->descr = strdup("Physical memory");
95 mem->units = pagesize;
96 mem->size = phys_mem/pagesize;
97 #if !defined(VM_TOTAL)
98 mem->free = free_mem;
99 #else
100 mem->free = total.t_free;
101 #endif
102 }
103
104 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_USERMEM, 1 );
105 if (!mem) {
106 snmp_log_perror("No (user) Memory info entry");
107 } else {
108 if (!mem->descr)
109 mem->descr = strdup("Real memory");
110 mem->units = pagesize;
111 #if !defined(VM_TOTAL)
112 mem->size = user_mem/pagesize;
113 mem->free = free_mem;
114 #else
115 mem->size = total.t_rm;
116 mem->free = total.t_rm - total.t_arm;
117 #endif
118 }
119
120 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_VIRTMEM, 1 );
121 if (!mem) {
122 snmp_log_perror("No Virtual Memory info entry");
123 } else {
124 if (!mem->descr)
125 mem->descr = strdup("Virtual memory");
126 mem->units = pagesize;
127 #if !defined(VM_TOTAL)
128 mem->size = mem_pages+swapTotal;
129 mem->free = free_mem+swapFree;
130 #else
131 mem->size = total.t_vm;
132 mem->free = total.t_vm - total.t_avm;
133 #endif
134 }
135
136 #if defined(VM_TOTAL)
137 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED, 1 );
138 if (!mem) {
139 snmp_log_perror("No Shared Memory info entry");
140 } else {
141 if (!mem->descr)
142 mem->descr = strdup("Shared virtual memory");
143 mem->units = pagesize;
144 mem->size = total.t_vmshr;
145 mem->free = total.t_vmshr - total.t_avmshr;
146 }
147
148 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SHARED2, 1 );
149 if (!mem) {
150 snmp_log_perror("No Shared2 Memory info entry");
151 } else {
152 if (!mem->descr)
153 mem->descr = strdup("Shared real memory");
154 mem->units = pagesize;
155 mem->size = total.t_rmshr;
156 mem->free = total.t_rmshr - total.t_armshr;
157 }
158 #endif
159
160 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_CACHED, 1 );
161 if (!mem) {
162 snmp_log_perror("No Cached Memory info entry");
163 } else {
164 if (!mem->descr)
165 mem->descr = strdup("Cached memory");
166 mem->units = pagesize;
167 mem->size = cache_count;
168 mem->free = 0;
169 }
170
171 nswap = swapmode(pagesize);
172 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP, 1 );
173 if (!mem) {
174 snmp_log_perror("No Swap info entry");
175 } else {
176 if (!mem->descr)
177 mem->descr = strdup( (nswap>1) ? "Swap space (total)"
178 : "Swap space");
179 mem->units = pagesize;
180 mem->size = swapTotal;
181 mem->free = swapFree;
182 }
183
184 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_MBUF, 1 );
185 if (!mem) {
186 snmp_log_perror("No Buffer, etc info entry");
187 } else {
188 if (!mem->descr)
189 mem->descr = strdup("Memory buffers");
190 mem->units = 1024;
191 mem->size = maxbufspace / 1024;
192 mem->free = (maxbufspace - bufspace)/1024;
193 }
194
195 return 0;
196 }
197
198
199
200 /*
201 * Retained from UCD implementation
202 */
203
204
205 #ifndef freebsd4
206 /*
207 * Executes swapinfo and parses last line
208 * This is just way too ugly ;)
209 */
210
211 static int
212 swapmode(long pagesize)
213 {
214 struct extensible ext;
215 int fd;
216 FILE *file;
217
218 strcpy(ext.command, "/usr/sbin/swapinfo -k");
219
220 if ((fd = get_exec_output(&ext)) != -1) {
221 file = fdopen(fd, "r");
222
223 while (fgets(ext.output, sizeof(ext.output), file) != NULL);
224
225 fclose(file);
226 wait_on_exec(&ext);
227
228 sscanf(ext.output, "%*s%*d%qd%qd", &swapUsed, &swapFree);
229
230 swapTotal = swapUsed + swapFree;
231 }
232 return 1;
233 }
234 #else
235 /*
236 * swapmode is based on a program called swapinfo written
237 * by Kevin Lahey <[email protected]>.
238 */
239
240 #include <sys/conf.h>
241
242 static int
243 swapmode(long pagesize)
244 {
245 int i, n;
246 struct kvm_swap kswap[16];
247 netsnmp_memory_info *mem;
248 char buf[1024];
249
250 n = kvm_getswapinfo(kd, kswap, sizeof(kswap) / sizeof(kswap[0]), 0);
251
252 swapUsed = swapTotal = swapFree = 0;
253
254 if ( n > 0 ) {
255 /*
256 * If there are multiple swap devices, then record
257 * the statistics for each one separately...
258 */
259 for (i = 0; i < n; ++i) {
260 mem = netsnmp_memory_get_byIdx( NETSNMP_MEM_TYPE_SWAP+1+i, 1 );
261 if (!mem)
262 continue;
263 if (!mem->descr) {
264 sprintf(buf, "swap %s", kswap[i].ksw_devname);
265 mem->descr = strdup( buf );
266 }
267 mem->units = pagesize;
268 mem->size = kswap[i].ksw_total;
269 mem->free = kswap[i].ksw_total - kswap[i].ksw_used;
270 /*
271 * ... and keep a running total for the overall swap stats
272 */
273 swapTotal += kswap[i].ksw_total;
274 swapUsed += kswap[i].ksw_used;
275 }
276 } else {
277 /*
278 * If there's only one swap device, then don't bother
279 * with individual statistics.
280 */
281 swapTotal += kswap[0].ksw_total;
282 swapUsed += kswap[0].ksw_used;
283 }
284
285 swapFree = swapTotal - swapUsed;
286 return n;
287 }
288 #endif
289