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.6 by pajs, Thu Apr 3 20:05:10 2003 UTC vs.
Revision 1.36 by tdb, Sun Feb 21 10:04:26 2010 UTC

#	Line 1 | Line 1
1	<	/*
2	<	* i-scream central monitoring system
3	<	* http://www.i-scream.org.uk
4	<	* Copyright (C) 2000-2002 i-scream
1	>	/*
2	>	* i-scream libstatgrab
3	>	* http://www.i-scream.org
4	>	* Copyright (C) 2000-2004 i-scream
5		*
6	<	* This program is free software; you can redistribute it and/or
7	<	* modify it under the terms of the GNU General Public License
8	<	* as published by the Free Software Foundation; either version 2
9	<	* of the License, or (at your option) any later version.
6	>	* This library is free software; you can redistribute it and/or
7	>	* modify it under the terms of the GNU Lesser General Public
8	>	* License as published by the Free Software Foundation; either
9	>	* version 2.1 of the License, or (at your option) any later version.
10		*
11	<	* This program is distributed in the hope that it will be useful,
11	>	* This library is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	<	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14	<	* GNU General Public License for more details.
13	>	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14	>	* Lesser General Public License for more details.
15		*
16	<	* You should have received a copy of the GNU General Public License
17	<	* along with this program; if not, write to the Free Software
18	<	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
16	>	* You should have received a copy of the GNU Lesser General Public
17	>	* License along with this library; if not, write to the Free Software
18	>	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19	>	* 02111-1307 USA
20	>	*
21	>	* $Id$
22		*/
23
24		#ifdef HAVE_CONFIG_H
#	Line 23 | Line 26
26		#endif
27
28		#include "statgrab.h"
29	+	#include "tools.h"
30		#ifdef SOLARIS
31		#include <unistd.h>
32		#include <kstat.h>
33		#endif
34	<	#ifdef LINUX
34	>	#if defined(LINUX) || defined(CYGWIN)
35		#include <stdio.h>
36		#include <string.h>
33	–	#include "tools.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	+	#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	<	mem_stat_t *get_memory_stats(){
64	>	sg_mem_stats *sg_get_mem_stats(){
65
66	<	static mem_stat_t mem_stat;
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 49 | Line 77 | mem_stat_t *get_memory_stats(){
77		long totalmem;
78		int pagesize;
79		#endif
80	<	#ifdef LINUX
80	>	#if defined(LINUX) || defined(CYGWIN)
81		char *line_ptr;
82	+	unsigned long long value;
83		FILE *f;
84		#endif
85	<	#ifdef FREEBSD
86	<	long inactive;
85	>	#if defined(FREEBSD) || defined(DFBSD)
86	>	int mib[2];
87	>	u_long physmem;
88		size_t size;
89	+	u_long free_count;
90	+	u_long cache_count;
91	+	u_long inactive_count;
92		int pagesize;
93		#endif
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	+	int pagesize, page_multiplier;
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;
158		mem_stat.used = mem_stat.total - mem_stat.free;
159		#endif
160
161	<	#ifdef LINUX
162	<	f=fopen("/proc/meminfo", "r");
163	<	if(f==NULL){
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
167	<	if((line_ptr=f_read_line(f, "Mem:"))==NULL){
168	<	fclose(f);
169	<	return NULL;
170	<	}
167	>	while ((line_ptr = sg_f_read_line(f, "")) != NULL) {
168	>	if (sscanf(line_ptr, "%*s %llu kB", &value) != 1) {
169	>	continue;
170	>	}
171	>	value *= 1024;
172
173	<	fclose(f);
174	<
175	<	/* Linux actually stores this as a unsigned long long, but
176	<	* our structures are just long longs. This shouldn't be a
177	<	* problem for sometime yet :)
178	<	*/
179	<	if((sscanf(line_ptr,"Mem:  %lld %lld %lld %*d %*d %lld", \
108	<	&mem_stat.total, \
109	<	&mem_stat.used, \
110	<	&mem_stat.free, \
111	<	&mem_stat.cache))!=4){
112	<	return NULL;
173	>	if (strncmp(line_ptr, "MemTotal:", 9) == 0) {
174	>	mem_stat.total = value;
175	>	} else if (strncmp(line_ptr, "MemFree:", 8) == 0) {
176	>	mem_stat.free = value;
177	>	} else if (strncmp(line_ptr, "Cached:", 7) == 0) {
178	>	mem_stat.cache = value;
179	>	}
180		}
181
182	+	fclose(f);
183	+	mem_stat.used = mem_stat.total - mem_stat.free;
184		#endif
185
186	<	#ifdef FREEBSD
187	<	/* Returns byes */
188	<	if (sysctlbyname("hw.physmem", NULL, &size, NULL, NULL) < 0){
186	>	#if defined(FREEBSD) || defined(DFBSD)
187	>	/* Returns bytes */
188	>	mib[0] = CTL_HW;
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	<	if (sysctlbyname("hw.physmem", &mem_stat.total, &size, NULL, NULL) < 0){
123	<	return NULL;
124	<	}
194	>	}
195	>	mem_stat.total = physmem;
196
197		/*returns pages*/
198	<	if (sysctlbyname("vm.stats.vm.v_free_count", NULL, &size, NULL, NULL) < 0){
198	>	size = sizeof free_count;
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	<	}
130	<	if (sysctlbyname("vm.stats.vm.v_free_count", &mem_stat.free, &size, NULL, NULL) < 0){
131	<	return NULL;
132	<	}
203	>	}
204
205	<	if (sysctlbyname("vm.stats.vm.v_inactive_count", NULL, &size, NULL, NULL) < 0){
205	>	size = sizeof inactive_count;
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	<	}
137	<	if (sysctlbyname("vm.stats.vm.v_inactive_count", &inactive , &size, NULL, NULL) < 0){
138	<	return NULL;
139	<	}
210	>	}
211
212	<	if (sysctlbyname("vm.stats.vm.v_cache_count", NULL, &size, NULL, NULL) < 0){
212	>	size = sizeof cache_count;
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	<	}
144	<	if (sysctlbyname("vm.stats.vm.v_cache_count", &mem_stat.cache, &size, NULL, NULL) < 0){
145	<	return NULL;
146	<	}
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 get
221	<	* the system statistics by pagesize
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
221	>	* get the system statistics by pagesize
222		*/
223	<	if ((pagesize=getpagesize()) == -1){
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
227	>	* deal with too. So I'm going to add them to free memory :)
228	>	*/
229	>	mem_stat.free=(free_count*pagesize)+(inactive_count*pagesize);
230	>	mem_stat.used=physmem-mem_stat.free;
231	>	#endif
232	>
233	>	#if defined(NETBSD)
234	>	if ((uvm = sg_get_uvmexp()) == NULL) {
235		return NULL;
236		}
237
238	<	mem_stat.cache=mem_stat.cache*pagesize;
239	<	/* Of couse nothing is ever that simple :) And i have inactive pages to deal
240	<	* with too. So im goingto add them to free memory :)
238	>	mem_stat.total = uvm->pagesize * uvm->npages;
239	>	mem_stat.cache = uvm->pagesize * (uvm->filepages + uvm->execpages);
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	>	/* The code in this section is based on the code in the OpenBSD
246	>	* top utility, located at src/usr.bin/top/machine.c in the
247	>	* OpenBSD source tree.
248	>	*
249	>	* For fun, and like OpenBSD top, we will do the multiplication
250	>	* converting the memory stats in pages to bytes in base 2.
251		*/
160	–	mem_stat.free=(mem_stat.free*pagesize)+(inactive*pagesize);
161	–
162	–	mem_stat.used=mem_stat.total-mem_stat.free;
252
253	+	/* All memory stats in OpenBSD are returned as the number of pages.
254	+	* To convert this into the number of bytes we need to know the
255	+	* page size on this system.
256	+	*/
257	+	pagesize = sysconf(_SC_PAGESIZE);
258	+
259	+	/* The pagesize gives us the base 10 multiplier, so we need to work
260	+	* out what the base 2 multiplier is. This means dividing
261	+	* pagesize by 2 until we reach unity, and counting the number of
262	+	* divisions required.
263	+	*/
264	+	page_multiplier = 0;
265	+
266	+	while (pagesize > 1) {
267	+	page_multiplier++;
268	+	pagesize >>= 1;
269	+	}
270	+
271	+	/* We can now ret the the raw VM stats (in pages) using the
272	+	* sysctl interface.
273	+	*/
274	+	mib[0] = CTL_VM;
275	+	mib[1] = VM_METER;
276	+	size = sizeof(vmtotal);
277	+
278	+	if (sysctl(mib, 2, &vmtotal, &size, NULL, 0) < 0) {
279	+	bzero(&vmtotal, sizeof(vmtotal));
280	+	sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_VM.VM_METER");
281	+	return NULL;
282	+	}
283	+
284	+	/* Convert the raw stats to bytes, and return these to the caller
285	+	*/
286	+	mem_stat.used = (vmtotal.t_rm << page_multiplier);   /* total real mem in use */
287	+	mem_stat.cache = 0;                                  /* no cache stats */
288	+	mem_stat.free = (vmtotal.t_free << page_multiplier); /* free memory pages */
289	+	mem_stat.total = (mem_stat.used + mem_stat.free);
290		#endif
291
292	+	#ifdef WIN32
293	+	memstats.dwLength = sizeof(memstats);
294	+	if (!GlobalMemoryStatusEx(&memstats)) {
295	+	sg_set_error_with_errno(SG_ERROR_MEMSTATUS, NULL);
296	+	return NULL;
297	+	}
298	+	mem_stat.free = memstats.ullAvailPhys;
299	+	mem_stat.total = memstats.ullTotalPhys;
300	+	mem_stat.used = mem_stat.total - mem_stat.free;
301	+	if(read_counter_large(SG_WIN32_MEM_CACHE, &mem_stat.cache)) {
302	+	mem_stat.cache = 0;
303	+	}
304	+	#endif
305		return &mem_stat;
167	–
306		}

Diff Legend

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