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.20 by tdb, Thu Feb 12 23:04:52 2004 UTC vs.
Revision 1.32 by tdb, Sat Sep 24 13:29:22 2005 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 35 | Line 35
35		#include <stdio.h>
36		#include <string.h>
37		#endif
38	<	#ifdef FREEBSD
38	>	#if defined(FREEBSD) || defined(DFBSD)
39		#include <sys/types.h>
40		#include <sys/sysctl.h>
41		#include <unistd.h>
42		#endif
43	<	#ifdef OPENBSD
44	<	#include <stdlib.h>
43	>	#if defined(NETBSD) || defined(OPENBSD)
44		#include <sys/param.h>
45	<	#include <sys/sysctl.h>
45	>	#include <sys/time.h>
46		#include <uvm/uvm.h>
47		#endif
48	+	#ifdef HPUX
49	+	#include <sys/param.h>
50	+	#include <sys/pstat.h>
51	+	#include <unistd.h>
52	+	#endif
53	+	#ifdef WIN32
54	+	#include <windows.h>
55	+	#include "win32.h"
56	+	#endif
57
58	<	mem_stat_t *get_memory_stats(){
58	>	sg_mem_stats *sg_get_mem_stats(){
59
60	<	static mem_stat_t mem_stat;
60	>	static sg_mem_stats mem_stat;
61
62	+	#ifdef HPUX
63	+	struct pst_static *pstat_static;
64	+	struct pst_dynamic pstat_dynamic;
65	+	long long pagesize;
66	+	#endif
67		#ifdef SOLARIS
68		kstat_ctl_t *kc;
69		kstat_t *ksp;
#	Line 63 | Line 76 | mem_stat_t *get_memory_stats(){
76		unsigned long long value;
77		FILE *f;
78		#endif
79	<	#ifdef FREEBSD
79	>	#if defined(FREEBSD) || defined(DFBSD)
80		int mib[2];
81		u_long physmem;
82		size_t size;
#	Line 75 | Line 88 | mem_stat_t *get_memory_stats(){
88		#if defined(NETBSD) || defined(OPENBSD)
89		struct uvmexp *uvm;
90		#endif
91	<	#ifdef OPENBSD
92	<	int mib[2];
80	<	size_t size;
91	>	#ifdef WIN32
92	>	MEMORYSTATUSEX memstats;
93		#endif
94
95	+	#ifdef HPUX
96	+	if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
97	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
98	+	return NULL;
99	+	}
100	+
101	+	if (pstat_getdynamic(&pstat_dynamic, sizeof(pstat_dynamic), 1, 0) == -1) {
102	+	sg_set_error_with_errno(SG_ERROR_PSTAT, "pstat_dynamic");
103	+	return NULL;
104	+	}
105	+	pstat_static = sg_get_pstat_static();
106	+	if (pstat_static == NULL) {
107	+	return NULL;
108	+	}
109	+
110	+	/* FIXME Does this include swap? */
111	+	mem_stat.total = ((long long) pstat_static->physical_memory) * pagesize;
112	+	mem_stat.free = ((long long) pstat_dynamic.psd_free) * pagesize;
113	+	mem_stat.used = mem_stat.total - mem_stat.free;
114	+	#endif
115		#ifdef SOLARIS
116		if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
117	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
118		return NULL;
119		}
120
121		if((totalmem=sysconf(_SC_PHYS_PAGES)) == -1){
122	+	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PHYS_PAGES");
123		return NULL;
124		}
125
126		if ((kc = kstat_open()) == NULL) {
127	+	sg_set_error(SG_ERROR_KSTAT_OPEN, NULL);
128		return NULL;
129		}
130		if((ksp=kstat_lookup(kc, "unix", 0, "system_pages")) == NULL){
131	+	sg_set_error(SG_ERROR_KSTAT_LOOKUP, "unix,0,system_pages");
132		return NULL;
133		}
134		if (kstat_read(kc, ksp, 0) == -1) {
135	+	sg_set_error(SG_ERROR_KSTAT_READ, NULL);
136		return NULL;
137		}
138		if((kn=kstat_data_lookup(ksp, "freemem")) == NULL){
139	+	sg_set_error(SG_ERROR_KSTAT_DATA_LOOKUP, "freemem");
140		return NULL;
141		}
142	<	kstat_close(kc);
142	>	kstat_close(kc);
143
144		mem_stat.total = (long long)totalmem * (long long)pagesize;
145		mem_stat.free = ((long long)kn->value.ul) * (long long)pagesize;
#	Line 110 | Line 148 | mem_stat_t *get_memory_stats(){
148
149		#if defined(LINUX) || defined(CYGWIN)
150		if ((f = fopen("/proc/meminfo", "r")) == NULL) {
151	+	sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/meminfo");
152		return NULL;
153		}
154
155	<	while ((line_ptr = f_read_line(f, "")) != NULL) {
155	>	while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
156		if (sscanf(line_ptr, "%*s %llu kB", &value) != 1) {
157		continue;
158		}
#	Line 132 | Line 171 | mem_stat_t *get_memory_stats(){
171		mem_stat.used = mem_stat.total - mem_stat.free;
172		#endif
173
174	<	#ifdef FREEBSD
174	>	#if defined(FREEBSD) || defined(DFBSD)
175		/* Returns bytes */
176		mib[0] = CTL_HW;
177		mib[1] = HW_PHYSMEM;
178		size = sizeof physmem;
179		if (sysctl(mib, 2, &physmem, &size, NULL, 0) < 0) {
180	+	sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_HW.HW_PHYSMEM");
181		return NULL;
182		}
183		mem_stat.total = physmem;
184
185		/*returns pages*/
186		size = sizeof free_count;
187	<	if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
187	>	if (sysctlbyname("vm.stats.vm.v_free_count", &free_count, &size, NULL, 0) < 0){
188	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
189	>	"vm.stats.vm.v_free_count");
190		return NULL;
191	<	}
191	>	}
192
193		size = sizeof inactive_count;
194	<	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
194	>	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive_count , &size, NULL, 0) < 0){
195	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
196	>	"vm.stats.vm.v_inactive_count");
197		return NULL;
198	<	}
198	>	}
199
200		size = sizeof cache_count;
201	<	if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
201	>	if (sysctlbyname("vm.stats.vm.v_cache_count", &cache_count, &size, NULL, 0) < 0){
202	>	sg_set_error_with_errno(SG_ERROR_SYSCTLBYNAME,
203	>	"vm.stats.vm.v_cache_count");
204		return NULL;
205	<	}
205	>	}
206
207		/* Because all the vm.stats returns pages, I need to get the page size.
208	<	* After that I then need to multiple the anything that used vm.stats to
208	>	* After that I then need to multiple the anything that used vm.stats to
209		* get the system statistics by pagesize
210		*/
211	<	if ((pagesize=getpagesize()) == -1){
166	<	return NULL;
167	<	}
168	<
211	>	pagesize = getpagesize();
212		mem_stat.cache=cache_count*pagesize;
213
214		/* Of couse nothing is ever that simple :) And I have inactive pages to
#	Line 175 | Line 218 | mem_stat_t *get_memory_stats(){
218		mem_stat.used=physmem-mem_stat.free;
219		#endif
220
221	<	#ifdef NETBSD
222	<	if ((uvm = get_uvmexp()) == NULL) {
221	>	#if defined(NETBSD) || defined(OPENBSD)
222	>	if ((uvm = sg_get_uvmexp()) == NULL) {
223		return NULL;
224		}
182	–	#endif
183	–	#ifdef OPENBSD
184	–	mib[0] = CTL_VM;
185	–	mib[1] = VM_UVMEXP;
225
187	–	if (sysctl(mib, 2, NULL, &size, NULL, 0) < 0) {
188	–	return NULL;
189	–	}
190	–
191	–	uvm = malloc(size);
192	–	if (uvm == NULL) {
193	–	return NULL;
194	–	}
195	–
196	–	if (sysctl(mib, 2, uvm, &size, NULL, 0) < 0) {
197	–	return NULL;
198	–	}
199	–	#endif
200	–	#if defined(NETBSD) || defined(OPENBSD)
226		mem_stat.total = uvm->pagesize * uvm->npages;
227		#ifdef NETBSD
228		mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
229		#else
230	+	/* Can't find cache memory on OpenBSD */
231		mem_stat.cache = 0;
232		#endif
233		mem_stat.free = uvm->pagesize * (uvm->free + uvm->inactive);
234		mem_stat.used = mem_stat.total - mem_stat.free;
235		#endif
236
237	<	#ifdef OPENBSD
238	<	free(uvm);
237	>	#ifdef WIN32
238	>	memstats.dwLength = sizeof(memstats);
239	>	if (!GlobalMemoryStatusEx(&memstats)) {
240	>	sg_set_error_with_errno(SG_ERROR_MEMSTATUS, NULL);
241	>	return NULL;
242	>	}
243	>	mem_stat.free = memstats.ullAvailPhys;
244	>	mem_stat.total = memstats.ullTotalPhys;
245	>	mem_stat.used = mem_stat.total - mem_stat.free;
246	>	if(read_counter_large(SG_WIN32_MEM_CACHE, &mem_stat.cache)) {
247	>	mem_stat.cache = 0;
248	>	}
249		#endif
214	–
250		return &mem_stat;
251		}

Diff Legend

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