ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/libstatgrab/memory_stats.c

Comparing projects/libstatgrab/src/libstatgrab/memory_stats.c (file contents):
Revision 1.24 by ats, Mon Apr 5 15:40:15 2004 UTC vs.
Revision 1.33 by tdb, Sun Oct 29 23:01:16 2006 UTC

#	Line 1 | Line 1
1		/*
2	<	* i-scream central monitoring system
2	>	* i-scream libstatgrab
3		* http://www.i-scream.org
4		* Copyright (C) 2000-2004 i-scream
5		*
#	Line 40 | Line 40
40		#include <sys/sysctl.h>
41		#include <unistd.h>
42		#endif
43	<	#if defined(NETBSD) || defined(OPENBSD)
43	>	#if defined(NETBSD)
44		#include <sys/param.h>
45		#include <sys/time.h>
46		#include <uvm/uvm.h>
47		#endif
48	+	#if defined(OPENBSD)
49	+	#include <sys/param.h>
50	+	#include <sys/types.h>
51	+	#include <sys/sysctl.h>
52	+	#include <sys/unistd.h>
53	+	#endif
54	+	#ifdef HPUX
55	+	#include <sys/param.h>
56	+	#include <sys/pstat.h>
57	+	#include <unistd.h>
58	+	#endif
59	+	#ifdef WIN32
60	+	#include <windows.h>
61	+	#include "win32.h"
62	+	#endif
63
64		sg_mem_stats *sg_get_mem_stats(){
65
66		static sg_mem_stats mem_stat;
67
68	+	#ifdef HPUX
69	+	struct pst_static *pstat_static;
70	+	struct pst_dynamic pstat_dynamic;
71	+	long long pagesize;
72	+	#endif
73		#ifdef SOLARIS
74		kstat_ctl_t *kc;
75		kstat_t *ksp;
#	Line 71 | Line 91 | sg_mem_stats *sg_get_mem_stats(){
91		u_int inactive_count;
92		int pagesize;
93		#endif
94	<	#if defined(NETBSD) || defined(OPENBSD)
94	>	#if defined(NETBSD)
95		struct uvmexp *uvm;
96		#endif
97	+	#if defined(OPENBSD)
98	+	int mib[2];
99	+	struct vmtotal vmtotal;
100	+	size_t size;
101	+	static int pagesize, pageshift;
102	+	#endif
103	+	#ifdef WIN32
104	+	MEMORYSTATUSEX memstats;
105	+	#endif
106
107	+	#ifdef HPUX
108	+	if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
109	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
110	+	return NULL;
111	+	}
112	+
113	+	if (pstat_getdynamic(&pstat_dynamic, sizeof(pstat_dynamic), 1, 0) == -1) {
114	+	sg_set_error_with_errno(SG_ERROR_PSTAT, "pstat_dynamic");
115	+	return NULL;
116	+	}
117	+	pstat_static = sg_get_pstat_static();
118	+	if (pstat_static == NULL) {
119	+	return NULL;
120	+	}
121	+
122	+	/* FIXME Does this include swap? */
123	+	mem_stat.total = ((long long) pstat_static->physical_memory) * pagesize;
124	+	mem_stat.free = ((long long) pstat_dynamic.psd_free) * pagesize;
125	+	mem_stat.used = mem_stat.total - mem_stat.free;
126	+	#endif
127		#ifdef SOLARIS
128		if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
129	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
130		return NULL;
131		}
132
133		if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
134	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
135		return NULL;
136		}
137
138		if ((kc = kstat_open()) == NULL) {
139	+	sg_set_error(SG_ERROR_KSTAT_OPEN, NULL);
140		return NULL;
141		}
142		if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL){
143	+	sg_set_error(SG_ERROR_KSTAT_LOOKUP, "unix,0,system_pages");
144		return NULL;
145		}
146		if (kstat_read(kc, ksp, 0) == -1) {
147	+	sg_set_error(SG_ERROR_KSTAT_READ, NULL);
148		return NULL;
149		}
150		if((kn=kstat_data_lookup(ksp, "freemem")) == NULL){
151	+	sg_set_error(SG_ERROR_KSTAT_DATA_LOOKUP, "freemem");
152		return NULL;
153		}
154	<	kstat_close(kc);
154	>	kstat_close(kc);
155
156		mem_stat.total = (long long)totalmem * (long long)pagesize;
157		mem_stat.free = ((long long)kn->value.ul) * (long long)pagesize;
#	Line 105 | Line 160 | sg_mem_stats *sg_get_mem_stats(){
160
161		#if defined(LINUX) || defined(CYGWIN)
162		if ((f = fopen("/proc/meminfo", "r")) == NULL) {
163	+	sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/meminfo");
164		return NULL;
165		}
166
#	Line 133 | Line 189 | sg_mem_stats *sg_get_mem_stats(){
189		mib[1] = HW_PHYSMEM;
190		size = sizeof physmem;
191		if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
192	+	sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
193		return NULL;
194		}
195		mem_stat.total = physmem;
196
197		/*returns pages*/
198		size = sizeof free_count;
199	<	if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
199	>	if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
200	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
201	>	"vm.stats.vm.v_free_count");
202		return NULL;
203	<	}
203	>	}
204
205		size = sizeof inactive_count;
206	<	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
206	>	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
207	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
208	>	"vm.stats.vm.v_inactive_count");
209		return NULL;
210	<	}
210	>	}
211
212		size = sizeof cache_count;
213	<	if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
213	>	if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
214	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
215	>	"vm.stats.vm.v_cache_count");
216		return NULL;
217	<	}
217	>	}
218
219		/* Because all the vm.stats returns pages, I need to get the page size.
220	<	* After that I then need to multiple the anything that used vm.stats to
220	>	* After that I then need to multiple the anything that used vm.stats to
221		* get the system statistics by pagesize
222		*/
223	<	if ((pagesize=getpagesize()) == -1){
161	<	return NULL;
162	<	}
163	<
223	>	pagesize = getpagesize();
224		mem_stat.cache=cache_count*pagesize;
225
226		/* Of couse nothing is ever that simple :) And I have inactive pages to
#	Line 170 | Line 230 | sg_mem_stats *sg_get_mem_stats(){
230		mem_stat.used=physmem-mem_stat.free;
231		#endif
232
233	<	#if defined(NETBSD) || defined(OPENBSD)
233	>	#if defined(NETBSD)
234		if ((uvm = sg_get_uvmexp()) == NULL) {
235		return NULL;
236		}
237
238		mem_stat.total = uvm->pagesize * uvm->npages;
179	–	#ifdef NETBSD
239		mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
181	–	#else
182	–	/* Can't find cache memory on OpenBSD */
183	–	mem_stat.cache = 0;
184	–	#endif
240		mem_stat.free = uvm->pagesize * (uvm->free + uvm->inactive);
241		mem_stat.used = mem_stat.total - mem_stat.free;
242		#endif
243
244	+	#if defined(OPENBSD)
245	+	/* get the page size with "getpagesize" and calculate pageshift
246	+	* from it
247	+	*/
248	+	pagesize = getpagesize();
249	+	pageshift = 0;
250	+	while (pagesize > 1) {
251	+	pageshift++;
252	+	pagesize >>= 1;
253	+	}
254	+
255	+	/* we only need the amount of log(2)1024 for our conversion */
256	+	pageshift -= 10;        /* Log base 2 of 1024 is 10 (2^10 == 1024) */
257	+	#define pagetok(size) ((size) << pageshift)
258	+	mib[0] = CTL_VM;
259	+	mib[1] = VM_METER;
260	+	size = sizeof(vmtotal);
261	+	if (sysctl(mib, 2, &vmtotal, &size, NUSG_ERROR_SYSCTL, 0) < 0) {
262	+	sg_set_error_with_errno(SG_ERROR_SYSCTL,
263	+	"CTL_VM.VM_METER");
264	+	return NULL;
265	+	}
266	+	/* convert memory stats to Kbytes */
267	+	mem_stat.used = pagetok(vmtotal.t_rm);          /* total real mem in use */
268	+	mem_stat.cache = 0;                             /* ? */
269	+	mem_stat.free = pagetok(vmtotal.t_free);        /* free memory pages */
270	+	mem_stat.total = (mem_stat.used + mem_stat.free);
271	+	#endif
272	+
273	+	#ifdef WIN32
274	+	memstats.dwLength = sizeof(memstats);
275	+	if (!GlobalMemoryStatusEx(&memstats)) {
276	+	sg_set_error_with_errno(SG_ERROR_MEMSTATUS, NULL);
277	+	return NULL;
278	+	}
279	+	mem_stat.free = memstats.ullAvailPhys;
280	+	mem_stat.total = memstats.ullTotalPhys;
281	+	mem_stat.used = mem_stat.total - mem_stat.free;
282	+	if(read_counter_large(SG_WIN32_MEM_CACHE, &mem_stat.cache)) {
283	+	mem_stat.cache = 0;
284	+	}
285	+	#endif
286		return &mem_stat;
287		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines